From 25718bbf77423ceec441f2c0715a06fd21803bef Mon Sep 17 00:00:00 2001 From: Renato Byrro Date: Tue, 23 Sep 2025 13:48:21 -0300 Subject: [PATCH] Slack wrapper toolkit in Python with JSON definitions (#574) finally! --- docker/toolkits.txt | 1 + toolkits/slack_api/.pre-commit-config.yaml | 18 + toolkits/slack_api/.ruff.toml | 47 + toolkits/slack_api/LICENSE | 21 + toolkits/slack_api/Makefile | 55 + .../slack_api/arcade_slack_api/__init__.py | 0 .../arcade_slack_api/tools/__init__.py | 3274 +++++++++++++++++ .../wrapper_tools/AcceptSlackInvite.json | 269 ++ .../wrapper_tools/AddCallParticipants.json | 141 + .../wrapper_tools/AddSlackEmojiAlias.json | 141 + .../wrapper_tools/AddSlackReaction.json | 173 + .../ApproveSlackChannelInvitation.json | 141 + .../wrapper_tools/CheckApiCallingCode.json | 107 + .../CheckSlackDiscoverability.json | 110 + .../CreateSlackConversation.json | 177 + .../wrapper_tools/CreateSlackUserGroup.json | 333 ++ .../wrapper_tools/CustomUnfurlSlackUrls.json | 365 ++ .../DeleteScheduledSlackMessage.json | 173 + .../DenySharedInviteRequest.json | 141 + .../wrapper_tools/DisableUserGroup.json | 173 + .../wrapper_tools/EditSlackBookmark.json | 237 ++ .../wrapper_tools/EnableSlackFileSharing.json | 109 + .../wrapper_tools/EnableSlackUserGroup.json | 173 + .../FetchWorkspaceSettingsInfo.json | 109 + .../wrapper_tools/FindSlackUserByEmail.json | 109 + .../wrapper_tools/GetCallInformation.json | 109 + .../wrapper_tools/GetConversationInfo.json | 176 + .../GetCurrentSlackTeamInfo.json | 141 + .../GetExternalFileUploadUrl.json | 205 ++ .../wrapper_tools/GetIntegrationLogs.json | 301 ++ .../wrapper_tools/GetRemoteFileInfoSlack.json | 141 + .../wrapper_tools/GetSlackBotInfo.json | 141 + .../GetSlackConversationMembers.json | 176 + .../GetSlackMessagePermalink.json | 139 + .../GetSlackRemoteFilesInfo.json | 237 ++ .../GetSlackTeamPreferences.json | 75 + .../wrapper_tools/GetSlackThreadMessages.json | 336 ++ .../wrapper_tools/GetSlackUserPresence.json | 109 + .../wrapper_tools/GetSlackUserProfile.json | 142 + .../GetTeamBillableUsersInfo.json | 205 ++ .../wrapper_tools/GetTeamProfile.json | 109 + .../wrapper_tools/GetUserIdentity.json | 76 + .../InviteUserToSlackChannel.json | 173 + .../wrapper_tools/JoinSlackConversation.json | 110 + .../ListAccessibleSlackConversations.json | 272 ++ .../ListApprovedWorkspaceInviteRequests.json | 173 + .../ListChannelsForUsergroup.json | 173 + .../wrapper_tools/ListCustomEmojiForTeam.json | 109 + .../ListDeniedSlackInviteRequests.json | 173 + .../ListPendingWorkspaceInvites.json | 173 + .../wrapper_tools/ListPinnedItems.json | 109 + .../wrapper_tools/ListScheduledMessages.json | 267 ++ .../ListSharedChannelInvites.json | 173 + .../wrapper_tools/ListSlackChannels.json | 240 ++ .../ListSlackEnterpriseEmojis.json | 141 + .../wrapper_tools/ListSlackTeamUsers.json | 206 ++ .../wrapper_tools/ListSlackUserGroups.json | 205 ++ .../ListSlackWorkspaceOwners.json | 173 + .../wrapper_tools/ListTeamsInEnterprise.json | 141 + .../wrapper_tools/ListWorkspaceUsers.json | 269 ++ .../OpenOrResumeSlackConversation.json | 209 ++ .../wrapper_tools/PinItemToSlackChannel.json | 141 + .../wrapper_tools/RegisterSlackCall.json | 333 ++ .../wrapper_tools/RemoveCallParticipants.json | 141 + .../wrapper_tools/RemoveReactionFromItem.json | 237 ++ .../wrapper_tools/RemoveSlackBookmark.json | 173 + .../wrapper_tools/RenameSlackEmoji.json | 141 + .../wrapper_tools/RevokeSlackToken.json | 107 + .../wrapper_tools/ScheduleSlackMessage.json | 493 +++ .../wrapper_tools/SearchFilesInSlack.json | 301 ++ .../wrapper_tools/SearchSlackMessages.json | 333 ++ .../SendEphemeralMessageSlack.json | 461 +++ .../wrapper_tools/SendSlackMessage.json | 619 ++++ .../SetSlackChannelReadCursor.json | 145 + .../wrapper_tools/SetSlackProfilePhoto.json | 205 ++ .../wrapper_tools/SetSlackWorkspaceName.json | 141 + .../SetWorkspaceDescription.json | 141 + .../ShareRemoteFileInChannel.json | 173 + .../wrapper_tools/UpdateSlackUserGroup.json | 365 ++ .../UpdateSlackUsergroupUsers.json | 269 ++ toolkits/slack_api/pyproject.toml | 61 + toolkits/slack_api/tests/__init__.py | 0 82 files changed, 17884 insertions(+) create mode 100644 toolkits/slack_api/.pre-commit-config.yaml create mode 100644 toolkits/slack_api/.ruff.toml create mode 100644 toolkits/slack_api/LICENSE create mode 100644 toolkits/slack_api/Makefile create mode 100644 toolkits/slack_api/arcade_slack_api/__init__.py create mode 100644 toolkits/slack_api/arcade_slack_api/tools/__init__.py create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/AcceptSlackInvite.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/AddCallParticipants.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/AddSlackEmojiAlias.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/AddSlackReaction.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ApproveSlackChannelInvitation.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/CheckApiCallingCode.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/CheckSlackDiscoverability.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/CreateSlackConversation.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/CreateSlackUserGroup.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/CustomUnfurlSlackUrls.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/DeleteScheduledSlackMessage.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/DenySharedInviteRequest.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/DisableUserGroup.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/EditSlackBookmark.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/EnableSlackFileSharing.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/EnableSlackUserGroup.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/FetchWorkspaceSettingsInfo.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/FindSlackUserByEmail.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetCallInformation.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetConversationInfo.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetCurrentSlackTeamInfo.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetExternalFileUploadUrl.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetIntegrationLogs.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetRemoteFileInfoSlack.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackBotInfo.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackConversationMembers.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackMessagePermalink.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackRemoteFilesInfo.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackTeamPreferences.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackThreadMessages.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackUserPresence.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackUserProfile.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetTeamBillableUsersInfo.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetTeamProfile.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/GetUserIdentity.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/InviteUserToSlackChannel.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/JoinSlackConversation.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListAccessibleSlackConversations.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListApprovedWorkspaceInviteRequests.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListChannelsForUsergroup.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListCustomEmojiForTeam.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListDeniedSlackInviteRequests.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListPendingWorkspaceInvites.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListPinnedItems.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListScheduledMessages.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSharedChannelInvites.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackChannels.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackEnterpriseEmojis.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackTeamUsers.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackUserGroups.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackWorkspaceOwners.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListTeamsInEnterprise.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ListWorkspaceUsers.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/OpenOrResumeSlackConversation.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/PinItemToSlackChannel.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/RegisterSlackCall.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/RemoveCallParticipants.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/RemoveReactionFromItem.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/RemoveSlackBookmark.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/RenameSlackEmoji.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/RevokeSlackToken.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ScheduleSlackMessage.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/SearchFilesInSlack.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/SearchSlackMessages.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/SendEphemeralMessageSlack.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/SendSlackMessage.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/SetSlackChannelReadCursor.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/SetSlackProfilePhoto.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/SetSlackWorkspaceName.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/SetWorkspaceDescription.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/ShareRemoteFileInChannel.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/UpdateSlackUserGroup.json create mode 100644 toolkits/slack_api/arcade_slack_api/wrapper_tools/UpdateSlackUsergroupUsers.json create mode 100644 toolkits/slack_api/pyproject.toml create mode 100644 toolkits/slack_api/tests/__init__.py diff --git a/docker/toolkits.txt b/docker/toolkits.txt index 1e5896cf..389cc1dd 100644 --- a/docker/toolkits.txt +++ b/docker/toolkits.txt @@ -40,3 +40,4 @@ arcade-outlook-calendar arcade-outlook-mail arcade-walmart arcade-youtube +arcade-slack_api diff --git a/toolkits/slack_api/.pre-commit-config.yaml b/toolkits/slack_api/.pre-commit-config.yaml new file mode 100644 index 00000000..3e1fd287 --- /dev/null +++ b/toolkits/slack_api/.pre-commit-config.yaml @@ -0,0 +1,18 @@ +files: ^.*/math/.* +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: "v4.4.0" + hooks: + - id: check-case-conflict + - id: check-merge-conflict + - id: check-toml + - id: check-yaml + - id: end-of-file-fixer + - id: trailing-whitespace + + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.6.7 + hooks: + - id: ruff + args: [--fix] + - id: ruff-format diff --git a/toolkits/slack_api/.ruff.toml b/toolkits/slack_api/.ruff.toml new file mode 100644 index 00000000..19364180 --- /dev/null +++ b/toolkits/slack_api/.ruff.toml @@ -0,0 +1,47 @@ +target-version = "py310" +line-length = 100 +fix = true + +[lint] +select = [ + # flake8-2020 + "YTT", + # flake8-bandit + "S", + # flake8-bugbear + "B", + # flake8-builtins + "A", + # flake8-comprehensions + "C4", + # flake8-debugger + "T10", + # flake8-simplify + "SIM", + # isort + "I", + # mccabe + "C90", + # pycodestyle + "E", "W", + # pyflakes + "F", + # pygrep-hooks + "PGH", + # pyupgrade + "UP", + # ruff + "RUF", + # tryceratops + "TRY", +] + +[lint.per-file-ignores] +"*" = ["TRY003", "B904"] +"**/tests/*" = ["S101", "E501"] +"**/evals/*" = ["S101", "E501"] + + +[format] +preview = true +skip-magic-trailing-comma = false diff --git a/toolkits/slack_api/LICENSE b/toolkits/slack_api/LICENSE new file mode 100644 index 00000000..dfbb8b76 --- /dev/null +++ b/toolkits/slack_api/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025, Arcade AI + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/toolkits/slack_api/Makefile b/toolkits/slack_api/Makefile new file mode 100644 index 00000000..0a8969be --- /dev/null +++ b/toolkits/slack_api/Makefile @@ -0,0 +1,55 @@ +.PHONY: help + +help: + @echo "🛠️ github Commands:\n" + @grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' + +.PHONY: install +install: ## Install the uv environment and install all packages with dependencies + @echo "🚀 Creating virtual environment and installing all packages using uv" + @uv sync --active --all-extras --no-sources + @if [ -f .pre-commit-config.yaml ]; then uv run --no-sources pre-commit install; fi + @echo "✅ All packages and dependencies installed via uv" + +.PHONY: install-local +install-local: ## Install the uv environment and install all packages with dependencies with local Arcade sources + @echo "🚀 Creating virtual environment and installing all packages using uv" + @uv sync --active --all-extras + @if [ -f .pre-commit-config.yaml ]; then uv run pre-commit install; fi + @echo "✅ All packages and dependencies installed via uv" + +.PHONY: build +build: clean-build ## Build wheel file using poetry + @echo "🚀 Creating wheel file" + uv build + +.PHONY: clean-build +clean-build: ## clean build artifacts + @echo "🗑️ Cleaning dist directory" + rm -rf dist + +.PHONY: test +test: ## Test the code with pytest + @echo "🚀 Testing code: Running pytest" + @uv run --no-sources pytest -W ignore -v --cov --cov-config=pyproject.toml --cov-report=xml + +.PHONY: coverage +coverage: ## Generate coverage report + @echo "coverage report" + @uv run --no-sources coverage report + @echo "Generating coverage report" + @uv run --no-sources coverage html + +.PHONY: bump-version +bump-version: ## Bump the version in the pyproject.toml file by a patch version + @echo "🚀 Bumping version in pyproject.toml" + uv version --no-sources --bump patch + +.PHONY: check +check: ## Run code quality tools. + @if [ -f .pre-commit-config.yaml ]; then\ + echo "🚀 Linting code: Running pre-commit";\ + uv run --no-sources pre-commit run -a;\ + fi + @echo "🚀 Static type checking: Running mypy" + @uv run --no-sources mypy --config-file=pyproject.toml diff --git a/toolkits/slack_api/arcade_slack_api/__init__.py b/toolkits/slack_api/arcade_slack_api/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/toolkits/slack_api/arcade_slack_api/tools/__init__.py b/toolkits/slack_api/arcade_slack_api/tools/__init__.py new file mode 100644 index 00000000..c995b051 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/tools/__init__.py @@ -0,0 +1,3274 @@ +"""API Wrapper Tools for Slack + +DO NOT EDIT THIS MODULE DIRECTLY. + +THIS MODULE WAS AUTO-GENERATED BY TRANSPILING THE API WRAPPER TOOL JSON DEFINITIONS +IN THE ../wrapper_tools DIRECTORY INTO PYTHON CODE. ANY CHANGES TO THIS MODULE WILL +BE OVERWRITTEN BY THE TRANSPILER. +""" + +from typing import Annotated, Any + +import httpx +from arcade_tdk import ToolContext, tool +from arcade_tdk.auth import OAuth2 + + +def remove_none_values(data: dict[str, Any]) -> dict[str, Any]: + return {k: v for k, v in data.items() if v is not None} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["admin.teams:write"])) +async def add_slack_emoji_alias( + context: ToolContext, + emoji_alias_name: Annotated[ + str, + "The new alias for the specified emoji. Whitespace or colons will be automatically trimmed.", # noqa: E501 + ], + target_emoji_name: Annotated[ + str, + "The name of the existing emoji to which the new alias is being added. Remove any surrounding whitespace or colons.", # noqa: E501 + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'admin.emoji.addAlias'."]: + """Add an emoji alias in a Slack Enterprise organization. + + This tool calls the Slack API to add an alias for an emoji within a Slack Enterprise organization. It should be used when a user wants to create a new shortcut or name for an existing emoji. Requires appropriate admin permissions.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/admin.emoji.addAlias", + params=remove_none_values({"name": emoji_alias_name, "alias_for": target_emoji_name}), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["admin.teams:read"])) +async def list_slack_enterprise_emojis( + context: ToolContext, + pagination_cursor: Annotated[ + str | None, + "Cursor for fetching the next page of emojis. Use 'next_cursor' from the previous response.", # noqa: E501 + ] = None, + max_items_to_return: Annotated[ + int | None, + "The maximum number of emojis to return, between 1 and 1000 inclusive. (default: '100')", + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'admin.emoji.list'."]: + """Retrieve emojis for a Slack Enterprise organization. + + This tool uses the Slack Admin API to fetch a list of emojis available in a Slack Enterprise organization. It requires the appropriate OAuth scope to access team information.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/admin.emoji.list", + params=remove_none_values({"cursor": pagination_cursor, "limit": max_items_to_return}), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["admin.teams:write"])) +async def rename_slack_emoji( + context: ToolContext, + current_emoji_name: Annotated[ + str, + "The current name of the emoji to be renamed. Colons (:myemoji:) around the value are optional.", # noqa: E501 + ], + new_emoji_name: Annotated[ + str, "The new name to assign to the emoji in the Slack Enterprise organization." + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'admin.emoji.rename'."]: + """Rename an emoji in a Slack Enterprise organization. + + Use this tool to rename a custom emoji within a Slack Enterprise organization. It requires appropriate OAuth scope for team operations.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/admin.emoji.rename", + params=remove_none_values({"name": current_emoji_name, "new_name": new_emoji_name}), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["admin.invites:read"])) +async def list_approved_workspace_invite_requests( + context: ToolContext, + workspace_id: Annotated[ + str | None, + "ID for the Slack workspace where the invite requests were made. Required if the Enterprise org has more than one workspace.", # noqa: E501 + ] = None, + pagination_cursor: Annotated[ + str | None, + "Value of the `next_cursor` from the previous API response for paginating results.", + ] = None, + result_limit: Annotated[ + int | None, + "Specify the number of results to return, between 1 and 1000 inclusive. (default: '100')", + ] = None, +) -> Annotated[ + dict[str, Any], "Response from the API endpoint 'admin.inviteRequests.approved.list'." +]: + """Retrieve all approved workspace invite requests from Slack. + + This tool retrieves a list of all approved invite requests for a Slack workspace. It should be called when there is a need to review or manage approved invitations. The response will include details of each invitation request.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/admin.inviteRequests.approved.list", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "team_id": workspace_id, + "cursor": pagination_cursor, + "limit": result_limit, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["admin.invites:read"])) +async def list_denied_slack_invite_requests( + context: ToolContext, + workspace_team_id: Annotated[ + str | None, + "ID of the workspace where the invite requests were made. Required if the Enterprise org has multiple workspaces.", # noqa: E501 + ] = None, + pagination_cursor: Annotated[ + str | None, + "The cursor value from the previous API response to fetch the next set of results. Use this for pagination.", # noqa: E501 + ] = None, + result_limit: Annotated[ + int | None, + "Specify the number of denied invite request results to return, between 1 and 1000 inclusive. (default: '100')", # noqa: E501 + ] = None, +) -> Annotated[ + dict[str, Any], "Response from the API endpoint 'admin.inviteRequests.denied.list'." +]: + """Retrieve denied Slack workspace invite requests. + + This tool retrieves a list of all denied workspace invite requests on Slack. It should be called when there is a need to review or analyze denied invitations to a Slack workspace.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/admin.inviteRequests.denied.list", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "team_id": workspace_team_id, + "cursor": pagination_cursor, + "limit": result_limit, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["admin.invites:read"])) +async def list_pending_workspace_invites( + context: ToolContext, + workspace_id: Annotated[ + str | None, + "The ID of the workspace to list pending invite requests from. Required for multi-workspace enterprises.", # noqa: E501 + ] = None, + pagination_cursor: Annotated[ + str | None, + "The cursor value for fetching the next set of invite requests. Use the `next_cursor` from the previous response if available.", # noqa: E501 + ] = None, + result_limit: Annotated[ + int | None, + "The number of invite requests to return per call, must be between 1 and 1000. (default: '100')", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'admin.inviteRequests.list'."]: + """Retrieve all pending workspace invite requests from Slack. + + Use this tool to list all pending workspace invite requests in a Slack workspace. This can be useful for administrators managing team invitations. Requires 'admin.invites:read' OAuth scope.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/admin.inviteRequests.list", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "team_id": workspace_id, + "cursor": pagination_cursor, + "limit": result_limit, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["admin.teams:read"])) +async def list_teams_in_enterprise( + context: ToolContext, + maximum_items_to_return: Annotated[ + int | None, + "Specify the maximum number of teams to retrieve. Must be a positive integer, up to 1000. (default: '100')", # noqa: E501 + ] = None, + pagination_cursor: Annotated[ + str | None, + "Use this to retrieve the next page of results by setting it to the `next_cursor` from the previous response.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'admin.teams.list'."]: + """Retrieve all teams in an Enterprise organization on Slack. + + This tool retrieves a list of all teams within an Enterprise organization on Slack, utilizing the admin.teams.list endpoint. It should be called when information about the teams in an Enterprise organization is needed.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/admin.teams.list", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "limit": maximum_items_to_return, + "cursor": pagination_cursor, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["admin.teams:read"])) +async def list_slack_workspace_owners( + context: ToolContext, + workspace_id: Annotated[ + str, "The unique identifier of the Slack workspace for which to list the owners." + ], + maximum_items_to_return: Annotated[ + int | None, + "Specifies the maximum number of owners to return, ranging from 1 to 1000. (default: '100')", # noqa: E501 + ] = None, + pagination_cursor: Annotated[ + str | None, + "The cursor from the previous response used to fetch the next page of owners. Leave empty for the first page.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'admin.teams.owners.list'."]: + """Retrieve all owners in a Slack workspace. + + This tool retrieves a list of all the owners in a specified Slack workspace, using the admin.teams.owners.list API endpoint. It is useful for managing or viewing the user roles within a Slack workspace.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/admin.teams.owners.list", + params=remove_none_values({ + "team_id": workspace_id, + "limit": maximum_items_to_return, + "cursor": pagination_cursor, + }), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["admin.teams:read"])) +async def fetch_workspace_settings_info( + context: ToolContext, + slack_team_id: Annotated[ + str, + "The unique identifier of the Slack workspace (team) for which to fetch the settings information.", # noqa: E501 + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'admin.teams.settings.info'."]: + """Retrieve settings information for a Slack workspace. + + This tool calls the Slack API to fetch detailed information about settings in a specific workspace. It is useful for administrators who need to manage team settings. The tool requires appropriate OAuth scopes for access.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/admin.teams.settings.info", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({"team_id": slack_team_id}), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["admin.teams:write"])) +async def set_workspace_description( + context: ToolContext, + workspace_id: Annotated[ + str, "The unique identifier for the Slack workspace where the description will be updated." + ], + workspace_description: Annotated[ + str, "The new description to set for the Slack workspace. Provide a clear and concise text." + ], +) -> Annotated[ + dict[str, Any], "Response from the API endpoint 'admin.teams.settings.setDescription'." +]: + """Update the description of a Slack workspace. + + This tool updates the description of a specified workspace in Slack. It requires admin permissions with the 'admin.teams:write' scope. It should be called when there is a need to change or set a new description for a Slack team.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/admin.teams.settings.setDescription", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "team_id": workspace_id, + "description": workspace_description, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["admin.teams:write"])) +async def set_slack_workspace_name( + context: ToolContext, + workspace_id: Annotated[ + str, "Unique identifier for the Slack workspace whose name you want to update." + ], + new_workspace_name: Annotated[ + str, "The desired new name for the Slack workspace. This replaces the existing name." + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'admin.teams.settings.setName'."]: + """Update the name of a Slack workspace. + + Use this tool to update the name of a specified Slack workspace. This tool should be called when there's a need to change the workspace name. It requires appropriate permissions.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/admin.teams.settings.setName", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({"team_id": workspace_id, "name": new_workspace_name}), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["admin.usergroups:read"])) +async def list_channels_for_usergroup( + context: ToolContext, + usergroup_id: Annotated[ + str, + "The ID of the IDP group to list channels for. It identifies which organizational group to retrieve the default channels from.", # noqa: E501 + ], + workspace_id: Annotated[str | None, "The unique identifier for the Slack workspace."] = None, + include_member_count_in_channels: Annotated[ + bool | None, + "Set to true to include the count of members for each channel, otherwise set to false.", + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'admin.usergroups.listChannels'."]: + """Retrieve channels linked to an org-level user group in Slack. + + Fetches a list of channels associated with a specified organizational IDP group in Slack. This tool is useful for admins managing user groups and their related channels.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/admin.usergroups.listChannels", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "usergroup_id": usergroup_id, + "team_id": workspace_id, + "include_num_members": include_member_count_in_channels, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["admin.users:read"])) +async def list_workspace_users( + context: ToolContext, + workspace_team_id: Annotated[ + str | None, + "The ID of the Slack workspace (e.g., T1234) to filter users from. Only users from this workspace will be listed.", # noqa: E501 + ] = None, + pagination_cursor: Annotated[ + str | None, + "Use this to navigate through paginated results by setting it to the `next_cursor` from a previous response.", # noqa: E501 + ] = None, + user_retrieval_limit: Annotated[ + int | None, + "Maximum number of users to retrieve per page from the Slack workspace. (default: '100')", + ] = None, + return_only_active_users: Annotated[ + bool | None, + "Return only active users if true; return only deactivated users if false. Default is true.", # noqa: E501 + ] = None, + include_deactivated_user_workspaces: Annotated[ + bool | None, + "Include workspaces for users even if they are deactivated. Only applies with org token and no team_id. Default is false.", # noqa: E501 + ] = None, + return_only_guest_users: Annotated[ + bool | None, + "If true, returns only guests and their expiration dates that belong to the specified team_id.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'admin.users.list'."]: + """Retrieve a list of users from a Slack workspace. + + Use this tool to get a list of users in a specific Slack workspace. It's helpful for administrators who need to manage or view user information within the workspace.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/admin.users.list", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "team_id": workspace_team_id, + "cursor": pagination_cursor, + "is_active": return_only_active_users, + "include_deactivated_user_workspaces": include_deactivated_user_workspaces, + "only_guests": return_only_guest_users, + "limit": user_retrieval_limit, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack")) +async def check_api_calling_code( + context: ToolContext, + simulate_error_response: Annotated[ + str | None, + "Specify an error code to simulate an error response for testing API calls. Useful for testing error handling.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'api.test'."]: + """Verify the correctness of API calling code for Slack. + + This tool verifies the accuracy and functionality of an API calling code by calling Slack's API testing endpoint. It's useful for developers who want to check if their code successfully interacts with Slack's API.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/api.test", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({"error": simulate_error_response}), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack")) +async def revoke_slack_token( + context: ToolContext, + trigger_testing_mode: Annotated[ + bool | None, + "Set to true to trigger testing mode where the token will not be revoked. Useful for testing.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'auth.revoke'."]: + """Revoke a Slack authentication token. + + This tool is used to revoke a Slack authentication token via a GET request to the Slack API endpoint. It should be called when it is necessary to invalidate a token to ensure it is no longer usable.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/auth.revoke", + params=remove_none_values({"test": trigger_testing_mode}), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["bookmarks:write"])) +async def edit_slack_bookmark( + context: ToolContext, + slack_channel_id: Annotated[ + str, "The ID of the Slack channel where the bookmark will be updated." + ], + target_bookmark_id: Annotated[str, "The unique identifier of the bookmark you want to update."], + bookmark_title: Annotated[str | None, "The new title for the bookmark to update."] = None, + bookmark_link: Annotated[ + str | None, + "URL of the bookmark to be edited. Ensure it is a valid format starting with http or https.", # noqa: E501 + ] = None, + emoji_tag: Annotated[ + str | None, + "The emoji tag to apply to the bookmark link. It should be a valid emoji code (e.g., :smile:).", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'bookmarks.edit'."]: + """Edit an existing bookmark in a Slack channel. + + This tool is used to edit an existing bookmark in a specified Slack channel. It requires appropriate permissions and should be called when you need to update the details of a bookmark in any channel you have access to.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/bookmarks.edit", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "channel_id": slack_channel_id, + "bookmark_id": target_bookmark_id, + "title": bookmark_title, + "link": bookmark_link, + "emoji": emoji_tag, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["bookmarks:write"])) +async def remove_slack_bookmark( + context: ToolContext, + slack_channel_id_to_remove_bookmark: Annotated[ + str, + "The ID of the Slack channel from which the bookmark should be removed. This ID specifies the target channel and is required to locate and delete the bookmark.", # noqa: E501 + ], + bookmark_id_to_remove: Annotated[ + str, + "The ID of the bookmark to be removed from a Slack channel. Ensure it is specified correctly to delete the correct bookmark.", # noqa: E501 + ], + quip_section_id: Annotated[ + str | None, + "The ID of the Quip section to unbookmark. This is required to specify which section's bookmark should be removed.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'bookmarks.remove'."]: + """Remove a bookmark from a Slack channel. + + This tool removes a specified bookmark from a Slack channel. It should be called when a user wants to delete a bookmark that is no longer needed or relevant. Requires appropriate permissions to execute.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/bookmarks.remove", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "channel_id": slack_channel_id_to_remove_bookmark, + "bookmark_id": bookmark_id_to_remove, + "quip_section_id": quip_section_id, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["users:read"])) +async def get_slack_bot_info( + context: ToolContext, + target_bot_id: Annotated[ + str | None, + "The unique bot ID for which information is requested. This ID is specific to each workspace the bot is in.", # noqa: E501 + ] = None, + team_id_for_org_token_use: Annotated[ + str | None, + "Encoded team or enterprise ID where the bot exists. Required if using an organization token. Ignored if using a workspace-level token.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'bots.info'."]: + """Retrieve details about a Slack bot user. + + This tool fetches information about a bot user in Slack. It should be called when details about a specific Slack bot are needed, such as its name, ID, or other metadata.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/bots.info", + params=remove_none_values({"bot": target_bot_id, "team_id": team_id_for_org_token_use}), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["calls:write"])) +async def register_slack_call( + context: ToolContext, + unique_call_id: Annotated[ + str, + "A unique ID for the Call, provided by the 3rd-party Call provider. Ensure it is unique across all calls from your service.", # noqa: E501 + ], + call_join_url: Annotated[str, "The URL required for a client to join the Call on Slack."], + optional_human_readable_display_id: Annotated[ + str | None, + "An optional, human-readable ID for the call, supplied by the third-party provider. This ID will be displayed in the Call object if given.", # noqa: E501 + ] = None, + desktop_app_join_url: Annotated[ + str | None, + "The URL used to directly launch the 3rd-party Call from Slack clients, if provided.", + ] = None, + call_start_timestamp: Annotated[ + int | None, "Unix timestamp indicating when the call is scheduled to start." + ] = None, + call_title: Annotated[ + str | None, + "The name of the Call to be registered on Slack. This title will be used to identify the Call within Slack.", # noqa: E501 + ] = None, + call_creator_user_id: Annotated[ + str | None, + "The valid Slack user ID of the creator of this call. Optional if using a user token, which defaults to the authed user.", # noqa: E501 + ] = None, + participants_info: Annotated[ + list[str] | None, + "A list of participants to register for the call, including 'slack_id', 'external_id', 'display_name', and 'avatar_url' for each user.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'calls.add'."]: + """Registers a new call on Slack. + + This tool registers a new call on Slack using the Slack API. It should be called when you want to create and log a new call event in a Slack workspace. The tool requires appropriate permissions (calls:write scope).""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/calls.add", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "external_unique_id": unique_call_id, + "join_url": call_join_url, + "external_display_id": optional_human_readable_display_id, + "desktop_app_join_url": desktop_app_join_url, + "date_start": call_start_timestamp, + "title": call_title, + "created_by": call_creator_user_id, + "users": participants_info, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["calls:read"])) +async def get_call_information( + context: ToolContext, + call_id: Annotated[ + str, + "The unique identifier of the call as returned by the `calls.add` method. This ID is necessary to retrieve detailed call information.", # noqa: E501 + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'calls.info'."]: + """Retrieve detailed information about a specific call in Slack. + + Use this tool to access detailed information about a call within Slack by providing the call ID. Useful for obtaining call metadata such as participants, start time, and more.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/calls.info", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({"id": call_id}), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["calls:write"])) +async def add_call_participants( + context: ToolContext, + call_id: Annotated[ + str, + "The unique identifier for the call, as returned by the `calls.add` method. This ID specifies which call the participants will be added to.", # noqa: E501 + ], + participant_users: Annotated[ + list[str], + "List of users to add, specified by `slack_id` or `external_id`. Include optional `display_name` and `avatar_url` for each user.", # noqa: E501 + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'calls.participants.add'."]: + """Add new participants to a Slack call. + + This tool registers new participants to an existing call in Slack. It should be used when you want to add people to a call that is already in progress or scheduled. The tool ensures participants are correctly added using the appropriate Slack API scope.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/calls.participants.add", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({"id": call_id, "users": participant_users}), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["calls:write"])) +async def remove_call_participants( + context: ToolContext, + call_id: Annotated[ + str, + "The unique identifier for the call from which participants are to be removed. This `id` is obtained from the `calls.add` method.", # noqa: E501 + ], + users_to_remove: Annotated[ + list[str], + "A list of user IDs to remove as participants from the call. Refer to Slack's documentation for specifying user IDs.", # noqa: E501 + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'calls.participants.remove'."]: + """Remove participants from a Slack call. + + This tool removes specified participants from a call in Slack by registering their removal. Useful when a user needs to manage call attendees.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/calls.participants.remove", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({"id": call_id, "users": users_to_remove}), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["chat:write"])) +async def delete_scheduled_slack_message( + context: ToolContext, + channel_id: Annotated[ + str, + "The ID of the channel where the scheduled message is set to post. Required to identify the correct message to delete.", # noqa: E501 + ], + scheduled_message_id: Annotated[ + str, + "The ID of the scheduled message to be deleted. This ID is obtained from the `chat.scheduleMessage` response.", # noqa: E501 + ], + delete_as_authenticated_user: Annotated[ + bool | None, + "Set to true to delete the message as the authenticated user with `chat:write:user` scope. Bot users are considered authenticated users. If false, the message will be deleted with `chat:write:bot` scope.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'chat.deleteScheduledMessage'."]: + """Delete a pending scheduled message from Slack queue. + + Use this tool to remove a scheduled message from the Slack queue. It requires \"chat:write\" OAuth scope, allowing you to manage messages as an authenticated user or bot.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/chat.deleteScheduledMessage", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "channel": channel_id, + "scheduled_message_id": scheduled_message_id, + "as_user": delete_as_authenticated_user, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack")) +async def get_slack_message_permalink( + context: ToolContext, + channel_id: Annotated[ + str, "The unique identifier of the Slack conversation or channel containing the message." + ], + message_timestamp: Annotated[ + str, + "The unique timestamp of the message to retrieve the permalink for. It identifies the message within the Slack channel.", # noqa: E501 + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'chat.getPermalink'."]: + """Retrieve a permalink URL for a specific Slack message. + + This tool retrieves a permalink URL for an existing message in Slack. Use it when you need the direct link to a particular message in a Slack channel.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/chat.getPermalink", + params=remove_none_values({"channel": channel_id, "message_ts": message_timestamp}), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["chat:write"])) +async def send_ephemeral_message_slack( + context: ToolContext, + target_channel: Annotated[ + str, + "The channel, private group, or IM channel where the ephemeral message will be sent. Accepts an encoded ID or the channel's name.", # noqa: E501 + ], + recipient_user_id: Annotated[ + str, + "The ID of the user who will receive the ephemeral message. Must be in the specified channel.", # noqa: E501 + ], + structured_attachments: Annotated[ + list[str] | None, + "A JSON-encoded array of structured attachments for the message. Presented as a URL-encoded string.", # noqa: E501 + ] = None, + structured_blocks: Annotated[ + list[str] | None, + "A URL-encoded JSON array of structured Slack block elements. Use for rich message formatting.", # noqa: E501 + ] = None, + message_icon_emoji: Annotated[ + str | None, + "Emoji to display as the message icon, overriding icon_url. Specify using the emoji name like :smile:.", # noqa: E501 + ] = None, + message_icon_url: Annotated[ + str | None, + "URL for the image to be used as the icon for the message. It overrides the icon_emoji if provided.", # noqa: E501 + ] = None, + message_markdown_text: Annotated[ + str | None, + "The main text formatted in markdown to be sent as an ephemeral message. Do not use with `blocks` or `text`. Character limit: 12,000.", # noqa: E501 + ] = None, + message_parse_mode: Annotated[ + str | None, + "Specifies how the message text is interpreted. Options are: 'none', 'full', 'mrkdwn', or 'false'. Defaults to 'none'. (default: 'none')", # noqa: E501 + ] = None, + ephemeral_message_text: Annotated[ + str | None, + "The main text of the ephemeral message for Slack. It acts as a fallback when using blocks; can be formatted as plain text or markdown. Limit to a few thousand bytes.", # noqa: E501 + ] = None, + parent_message_timestamp: Annotated[ + str | None, + "The timestamp of the parent message to post this ephemeral message in its thread. Ensure there is already an active thread.", # noqa: E501 + ] = None, + bot_username: Annotated[ + str | None, + "The username for the bot sending the ephemeral message. This sets the display name in the Slack message.", # noqa: E501 + ] = None, + link_names_auto_link: Annotated[ + bool | None, "Set to true to automatically find and link channel names and usernames." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'chat.postEphemeral'."]: + """Send an ephemeral message to a user in a Slack channel. + + This tool sends an ephemeral message to a user within a specified Slack channel. It's useful for sending temporary messages or notifications that only the specified user can see. Requires the 'chat:write' scope.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/chat.postEphemeral", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "channel": target_channel, + "user": recipient_user_id, + "attachments": structured_attachments, + "blocks": structured_blocks, + "icon_emoji": message_icon_emoji, + "icon_url": message_icon_url, + "link_names": link_names_auto_link, + "markdown_text": message_markdown_text, + "parse": message_parse_mode, + "text": ephemeral_message_text, + "thread_ts": parent_message_timestamp, + "username": bot_username, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["chat:write"])) +async def send_slack_message( + context: ToolContext, + target_channel_id_or_name: Annotated[ + str, + "The encoded ID or name of the channel, private group, or IM where the message will be sent. Retrieve using Slack's conversations.list API.", # noqa: E501 + ], + message_attachments: Annotated[ + list[str] | None, + 'A JSON array of structured attachment objects for the message, provided as a URL-encoded string. Example: `[{"pretext": "pre-hello", "text": "text-world"}]`.', # noqa: E501 + ] = None, + structured_blocks: Annotated[ + list[str] | None, + "A JSON-based array of structured blocks for constructing messages using Block Kit. Provide as a URL-encoded string. Include fallback text if necessary.", # noqa: E501 + ] = None, + emoji_icon_for_message: Annotated[ + str | None, + "Emoji to display as the icon for the Slack message. Overrides any image URL icon.", + ] = None, + message_icon_url: Annotated[ + str | None, + "URL to an image to use as the icon for the message. Overrides any specified icon emoji.", + ] = None, + message_markdown: Annotated[ + str | None, + "The message text formatted using markdown, up to 12,000 characters. Cannot be used with `blocks` or `text`.", # noqa: E501 + ] = None, + message_metadata: Annotated[ + str | None, + "A JSON object with 'event_type' and 'event_payload' fields, URL-encoded, providing additional metadata for the message.", # noqa: E501 + ] = None, + parse_mode: Annotated[ + str | None, + "Specifies how the message content should be treated. Options are 'none' to remove hyperlinks or 'full' to ignore markdown formatting.", # noqa: E501 + ] = None, + message_text: Annotated[ + str | None, + "The main text of the message. Acts as the primary message or a fallback for notifications when using blocks. Supports plain text or markdown.", # noqa: E501 + ] = None, + thread_timestamp: Annotated[ + str | None, + "Timestamp of the parent message to which this message will be a reply. Use the parent's `ts` value, not a reply's.", # noqa: E501 + ] = None, + bot_username: Annotated[ + str | None, "The display name to use for the bot when sending the message to Slack." + ] = None, + post_as_authenticated_user: Annotated[ + bool | None, + "Set to true to post the message as the authenticated user instead of as a bot. Only applicable for classic apps.", # noqa: E501 + ] = None, + link_user_groups: Annotated[ + bool | None, + "Enable linking of user groups in the message. Individual user linking is not supported.", + ] = None, + enable_slack_markup_parsing: Annotated[ + bool | None, + "Set to true to enable Slack markup parsing in the message. Default is enabled.", + ] = None, + broadcast_reply_to_channel: Annotated[ + bool | None, + "Set to true to make the reply visible to everyone in the channel when responding to a thread. Use with 'thread_ts'. Default is false.", # noqa: E501 + ] = None, + enable_unfurling_text_content: Annotated[ + bool | None, + "Set to true to enable unfurling of primarily text-based content in Slack messages.", + ] = None, + disable_media_unfurling: Annotated[ + bool | None, + "Set to false to enable media unfurling and true to disable it. (default: 'false')", + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'chat.postMessage'."]: + """Sends a message to a Slack channel. + + This tool allows you to send messages to a Slack channel or direct message on behalf of an authenticated user. It is useful for automating communications within Slack workspaces.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/chat.postMessage", + method="POST", + headers=remove_none_values({ + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ) + }), + data=remove_none_values({ + "channel": target_channel_id_or_name, + "as_user": post_as_authenticated_user, + "attachments": message_attachments, + "blocks": structured_blocks, + "icon_emoji": emoji_icon_for_message, + "icon_url": message_icon_url, + "link_names": link_user_groups, + "markdown_text": message_markdown, + "metadata": message_metadata, + "mrkdwn": enable_slack_markup_parsing, + "parse": parse_mode, + "reply_broadcast": broadcast_reply_to_channel, + "text": message_text, + "thread_ts": thread_timestamp, + "unfurl_links": enable_unfurling_text_content, + "unfurl_media": disable_media_unfurling, + "username": bot_username, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack")) +async def list_scheduled_messages( + context: ToolContext, + channel_id: Annotated[ + str | None, "The ID of the Slack channel from which to retrieve scheduled messages." + ] = None, + pagination_cursor: Annotated[ + str | None, + "Cursor value for pagination to specify the starting point of the list from a previous call.", # noqa: E501 + ] = None, + latest_timestamp: Annotated[ + str | None, + "A Unix timestamp marking the latest point in the time range for fetching scheduled messages. Ensure it is greater than the `oldest` timestamp if both are set.", # noqa: E501 + ] = None, + max_number_of_entries: Annotated[ + int | None, "Specify the maximum number of scheduled messages to return from Slack." + ] = None, + oldest_timestamp: Annotated[ + str | None, + "A Unix timestamp representing the start of the time range for scheduled messages. It must be less than the `latest_timestamp` if both are specified.", # noqa: E501 + ] = None, + team_id: Annotated[ + str | None, + "Encoded team ID to specify which team's channels to list. Required if using an org-level token; ignore for workspace-level tokens.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'chat.scheduledMessages.list'."]: + """Retrieve scheduled messages from Slack. + + Use this tool to obtain a list of messages that are scheduled to be sent in a Slack workspace. It is useful for managing future communications and staying informed of pending messages.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/chat.scheduledMessages.list", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "channel": channel_id, + "cursor": pagination_cursor, + "latest": latest_timestamp, + "limit": max_number_of_entries, + "oldest": oldest_timestamp, + "team_id": team_id, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["chat:write"])) +async def schedule_slack_message( + context: ToolContext, + slack_channel_id_or_name: Annotated[ + str, + "Specify the target Slack channel, private group, or DM. Use an encoded ID or the channel name. Retrieve channel ID via `conversations.list`.", # noqa: E501 + ], + schedule_time_unix_timestamp: Annotated[ + int, + "Unix timestamp for when the message should be posted to Slack. Must be within 120 days and not exceed 30 messages per 5-minute window.", # noqa: E501 + ], + attachments_json: Annotated[ + str | None, + "A JSON array of structured attachments as a URL-encoded string for the Slack message.", + ] = None, + structured_blocks_json: Annotated[ + str | None, + "A URL-encoded string of a JSON-based array containing structured blocks for message formatting.", # noqa: E501 + ] = None, + message_markdown: Annotated[ + str | None, + "Message text in markdown format. Avoid using with 'blocks' or 'text'. Maximum 12,000 characters.", # noqa: E501 + ] = None, + message_parsing_mode: Annotated[ + str | None, + "Specifies how the message content should be parsed and interpreted when sending to Slack. For more details, refer to chat.postMessage documentation.", # noqa: E501 + ] = None, + message_text: Annotated[ + str | None, + "The main body of the Slack message or a fallback text when using blocks. Can be plain text or formatted with mrkdwn.", # noqa: E501 + ] = None, + parent_message_timestamp: Annotated[ + str | None, + "Timestamp of the parent message to which this message is a reply. Use the original message's timestamp, not a reply's timestamp.", # noqa: E501 + ] = None, + metadata_json: Annotated[ + str | None, + "JSON object containing 'event_type' and 'event_payload' fields. Must be URL-encoded. Note: using this will prevent scheduled messages from posting.", # noqa: E501 + ] = None, + enable_group_linking: Annotated[ + bool | None, + "Set to true to link user groups in the message. Linking individual users is not supported; use mention syntax instead.", # noqa: E501 + ] = None, + make_reply_visible_to_everyone: Annotated[ + bool | None, + "Set to true to make the reply visible to everyone in the channel or conversation. Use with `thread_ts`. Defaults to false.", # noqa: E501 + ] = None, + enable_link_unfurling: Annotated[ + bool | None, "Pass true to enable unfurling of primarily text-based content." + ] = None, + disable_unfurling_of_media_content: Annotated[ + bool | None, "Set to true to disable unfurling of media content. Defaults to false." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'chat.scheduleMessage'."]: + """Schedule a message to be sent later in Slack. + + This tool schedules a message to be sent to a specific Slack channel at a designated future time. It utilizes the Slack API endpoint 'chat.scheduleMessage' and requires the 'chat:write' OAuth scope.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/chat.scheduleMessage", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "channel": slack_channel_id_or_name, + "post_at": schedule_time_unix_timestamp, + "attachments": attachments_json, + "blocks": structured_blocks_json, + "link_names": enable_group_linking, + "markdown_text": message_markdown, + "parse": message_parsing_mode, + "reply_broadcast": make_reply_visible_to_everyone, + "text": message_text, + "thread_ts": parent_message_timestamp, + "unfurl_links": enable_link_unfurling, + "unfurl_media": disable_unfurling_of_media_content, + "metadata": metadata_json, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["links:write"])) +async def custom_unfurl_slack_urls( + context: ToolContext, + channel_id: Annotated[ + str, + "ID of the Slack channel where the message is posted. Required with 'ts' for custom unfurl or with 'unfurl_id' and 'source'.", # noqa: E501 + ], + message_timestamp: Annotated[ + str, + "Timestamp of the message to which unfurl behavior will be added. Ensure it corresponds to a message in the specified channel containing a fully-qualified URL registered with your Slack app.", # noqa: E501 + ], + unfurl_url_map: Annotated[ + str, + "A URL-encoded JSON map with URLs as keys and their corresponding unfurl data as values. Each URL should point to a single attachment, like message buttons.", # noqa: E501 + ], + authentication_invitation_message: Annotated[ + str | None, + "A simple formatted string sent as an ephemeral message inviting the user to authenticate for full unfurl behavior. Supports Slack's *bold*, _italics_, and linking formatting. If provided, this takes precedence over `authentication_invitation_url`.", # noqa: E501 + ] = None, + custom_authentication_url: Annotated[ + str | None, + "A URL to redirect users for app authentication to enable full URL unfurling, requires URL encoding.", # noqa: E501 + ] = None, + user_authentication_blocks: Annotated[ + list[str] | None, + "A URL-encoded JSON array of structured blocks to send as an ephemeral message for user authentication invitation.", # noqa: E501 + ] = None, + unfurl_link_id: Annotated[ + str | None, "The ID of the link to unfurl. Must be used with 'source'." + ] = None, + link_source: Annotated[ + str | None, + "Specify the source of the link to unfurl as either 'composer' for links inside the message composer or 'conversations_history' for links posted to a conversation. Must be used with 'unfurl_id', or alternatively with 'channel' and 'ts'.", # noqa: E501 + ] = None, + require_user_authentication: Annotated[ + bool | None, + "Set to true if the user must install your Slack app to trigger unfurls for this domain.", + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'chat.unfurl'."]: + """Provide custom unfurl behavior for user-posted URLs on Slack. + + This tool should be called to customize how URLs posted by users are displayed in Slack by providing a custom unfurl behavior.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/chat.unfurl", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "channel": channel_id, + "ts": message_timestamp, + "unfurls": unfurl_url_map, + "user_auth_message": authentication_invitation_message, + "user_auth_required": require_user_authentication, + "user_auth_url": custom_authentication_url, + "user_auth_blocks": user_authentication_blocks, + "unfurl_id": unfurl_link_id, + "source": link_source, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["conversations.connect:write"])) +async def accept_slack_invite( + context: ToolContext, + channel_name: Annotated[ + str, + "Provide the desired name for the Slack Connect channel. If the channel doesn't exist in your workspace, this name will be assigned to it.", # noqa: E501 + ], + invite_id: Annotated[ + str | None, + "ID of the invitation you want to accept. Must provide either this or channel_id.", + ] = None, + slack_channel_id_to_accept: Annotated[ + str | None, + "The ID of the channel you would like to accept the invitation for. Either this or `invite_id` is required.", # noqa: E501 + ] = None, + workspace_id: Annotated[ + str | None, + "The ID of the workspace where the channel should be accepted. Required if using an org-level token.", # noqa: E501 + ] = None, + is_channel_private: Annotated[ + bool | None, "True to make the channel private; false to make it public." + ] = None, + use_free_trial: Annotated[ + bool | None, + "Set to 'True' to use your workspace's free trial to start using Slack Connect.", + ] = None, +) -> Annotated[ + dict[str, Any], "Response from the API endpoint 'conversations.acceptSharedInvite'." +]: + """Accept invitations to a Slack Connect channel. + + Use this tool to accept an invitation to a Slack Connect channel, facilitating seamless collaboration across different Slack workspaces.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/conversations.acceptSharedInvite", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "channel_name": channel_name, + "is_private": is_channel_private, + "free_trial_accepted": use_free_trial, + "invite_id": invite_id, + "channel_id": slack_channel_id_to_accept, + "team_id": workspace_id, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["conversations.connect:manage"])) +async def approve_slack_channel_invitation( + context: ToolContext, + shared_channel_invite_id: Annotated[ + str, + "The ID of the shared channel invitation you want to approve. It is required to specifically identify which invitation is being approved for the Slack Connect channel.", # noqa: E501 + ], + other_party_team_id: Annotated[ + str | None, + "The team or enterprise ID of the other party involved in the Slack Connect invitation you are approving.", # noqa: E501 + ] = None, +) -> Annotated[ + dict[str, Any], "Response from the API endpoint 'conversations.approveSharedInvite'." +]: + """Approve an invitation to a Slack Connect channel. + + This tool is used to approve invitations sent to a Slack Connect channel, allowing collaboration between different Slack workspaces. It should be called when a user wants to manage and approve channel access invitations.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/conversations.approveSharedInvite", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "invite_id": shared_channel_invite_id, + "target_team": other_party_team_id, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool( + requires_auth=OAuth2( + id="arcade-slack", + scopes=["channels:manage", "channels:write", "groups:write", "im:write", "mpim:write"], + ) +) +async def create_slack_conversation( + context: ToolContext, + channel_name: Annotated[ + str, + "The name of the new Slack channel to create. It must contain only lowercase letters, numbers, hyphens, and underscores, and be 80 characters or less.", # noqa: E501 + ], + encoded_team_id: Annotated[ + str | None, + "The encoded team ID where the channel will be created. Required when using an organization-level token. Ignored if using a workspace-level token.", # noqa: E501 + ] = None, + create_private_channel: Annotated[ + bool | None, "Set to true to create a private channel instead of a public one." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'conversations.create'."]: + """Create a new public or private Slack conversation. + + This tool is used to initiate a new conversation channel in Slack, allowing for the creation of either public or private channels. It is useful when setting up new communication threads within a team or project.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/conversations.create", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "name": channel_name, + "is_private": create_private_channel, + "team_id": encoded_team_id, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool( + requires_auth=OAuth2( + id="arcade-slack", scopes=["channels:read", "groups:read", "im:read", "mpim:read"] + ) +) +async def get_conversation_info( + context: ToolContext, + conversation_id: Annotated[ + str, "The unique ID of the Slack conversation to retrieve information for." + ], + include_locale: Annotated[ + bool | None, + "Set to `true` to receive the locale for this conversation. Defaults to `false`.", + ] = None, + include_member_count: Annotated[ + bool | None, + "Set to true to include the member count for the specified conversation. Defaults to false.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'conversations.info'."]: + """Fetches information about a Slack conversation. + + This tool retrieves details about a specific conversation in Slack, such as its name, members, and other relevant data. It should be used when information about a Slack conversation is needed, and requires appropriate read permissions.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/conversations.info", + params=remove_none_values({ + "channel": conversation_id, + "include_locale": include_locale, + "include_num_members": include_member_count, + }), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["conversations:write.invites"])) +async def invite_user_to_slack_channel( + context: ToolContext, + slack_channel_id: Annotated[ + str, + "The ID of the Slack channel to invite users to. It can be a public or private channel ID.", + ], + user_ids_list: Annotated[str, "A list of up to 100 user IDs to invite, separated by commas."], + continue_with_valid_users: Annotated[ + bool | None, + "Set to true to invite valid users while ignoring invalid IDs when multiple user IDs are provided. Default is false.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'conversations.invite'."]: + """Invite users to a Slack channel. + + This tool sends an invitation to specified users to join a Slack channel. It should be called when you want to add new members to a channel via an invite.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/conversations.invite", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "channel": slack_channel_id, + "users": user_ids_list, + "force": continue_with_valid_users, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["channels:join", "channels:write"])) +async def join_slack_conversation( + context: ToolContext, + conversation_id: Annotated[ + str, "The ID of the conversation or channel you want to join in Slack." + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'conversations.join'."]: + """Join an existing conversation in Slack. + + This tool is used to join a specified conversation within Slack. It requires appropriate user permissions and should be called when there's a need to participate in an existing Slack channel.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/conversations.join", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({"channel": conversation_id}), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool( + requires_auth=OAuth2( + id="arcade-slack", scopes=["channels:read", "groups:read", "im:read", "mpim:read"] + ) +) +async def list_slack_channels( + context: ToolContext, + pagination_cursor: Annotated[ + str | None, + "The cursor used to paginate through data collections. Use the `next_cursor` from a previous response to continue; omit for the first page.", # noqa: E501 + ] = None, + maximum_number_of_channels: Annotated[ + int | None, + "Specify the maximum number of channels to return. Must be an integer under 1000. Note that fewer channels than requested may be returned. (default: '100')", # noqa: E501 + ] = None, + team_id_for_org_app: Annotated[ + str | None, + "Encoded team ID to list channels. Required for org-level tokens; ignored for workspace-level tokens.", # noqa: E501 + ] = None, + channel_types: Annotated[ + str | None, + "Comma-separated list of channel types to include, e.g., 'public_channel', 'private_channel', 'mpim', 'im'. (default: 'public_channel')", # noqa: E501 + ] = None, + exclude_archived_channels: Annotated[ + bool | None, + "Set to true to exclude archived channels from the list of Slack channels. Default is false.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'conversations.list'."]: + """Retrieve a list of all channels in a Slack team. + + This tool retrieves a list of all public and private channels that the user has access to within a Slack team. It can also view direct and multiparty direct messages, depending on the user's permissions.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/conversations.list", + params=remove_none_values({ + "cursor": pagination_cursor, + "exclude_archived": exclude_archived_channels, + "limit": maximum_number_of_channels, + "team_id": team_id_for_org_app, + "types": channel_types, + }), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["conversations.connect:manage"])) +async def list_shared_channel_invites( + context: ToolContext, + workspace_team_id: Annotated[ + str | None, + "The encoded team ID for the workspace to retrieve invites from. Required when using an organization token.", # noqa: E501 + ] = None, + maximum_invites_to_return: Annotated[ + int | None, + "Specify the maximum number of unapproved shared channel invites to retrieve. (default: '100')", # noqa: E501 + ] = None, + pagination_cursor: Annotated[ + str | None, + "The cursor for paginating through results, obtained from a previous call's next_cursor.", + ] = None, +) -> Annotated[ + dict[str, Any], "Response from the API endpoint 'conversations.listConnectInvites'." +]: + """Retrieve unapproved shared channel invites from Slack. + + This tool retrieves a list of shared channel invites that have been generated or received but are not yet approved by all parties on Slack. It should be called when you need to manage or view pending shared channel invites.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/conversations.listConnectInvites", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "team_id": workspace_team_id, + "count": maximum_invites_to_return, + "cursor": pagination_cursor, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool( + requires_auth=OAuth2( + id="arcade-slack", + scopes=["channels:manage", "channels:write", "groups:write", "im:write", "mpim:write"], + ) +) +async def set_slack_channel_read_cursor( + context: ToolContext, + channel_id: Annotated[ + str, + "The ID of the Slack channel or conversation where you want to set the read cursor. This should be a valid Slack channel ID.", # noqa: E501 + ], + timestamp_of_message_to_mark_as_read: Annotated[ + str, + "The unique identifier (timestamp) of the message you want to mark as most recently seen in the conversation.", # noqa: E501 + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'conversations.mark'."]: + """Update the read cursor in a Slack channel. + + Use this tool to mark a specific point in a Slack channel as read. This is useful for keeping track of the latest read messages in channels, groups, or direct messages. Requires appropriate Slack OAuth scopes.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/conversations.mark", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "channel": channel_id, + "ts": timestamp_of_message_to_mark_as_read, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool( + requires_auth=OAuth2( + id="arcade-slack", scopes=["channels:read", "groups:read", "im:read", "mpim:read"] + ) +) +async def get_slack_conversation_members( + context: ToolContext, + conversation_id: Annotated[ + str, + "The ID of the Slack conversation to retrieve members from. This can be a channel, group, or direct message.", # noqa: E501 + ], + pagination_cursor: Annotated[ + str | None, + "Cursor for pagination, set to the `next_cursor` value from a previous response to continue retrieving members from a conversation.", # noqa: E501 + ] = None, + max_items_to_return: Annotated[ + int | None, + "The maximum number of conversation members to return. Recommended to specify a value under 1000, with no more than 200 results at a time for optimal pagination. (default: '100')", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'conversations.members'."]: + """Retrieve members from a specified Slack conversation. + + Use this tool to get a list of members in a specific Slack conversation. This can apply to public and private channels, as well as direct and multi-party direct message conversations. Appropriate OAuth scopes are required to access different types of conversations.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/conversations.members", + params=remove_none_values({ + "channel": conversation_id, + "cursor": pagination_cursor, + "limit": max_items_to_return, + }), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool( + requires_auth=OAuth2( + id="arcade-slack", + scopes=["channels:manage", "channels:write", "groups:write", "im:write", "mpim:write"], + ) +) +async def open_or_resume_slack_conversation( + context: ToolContext, + conversation_channel_id: Annotated[ + str | None, + "The ID of an existing direct or multi-person message channel to resume. Alternatively, provide the `users` field to start a new conversation.", # noqa: E501 + ] = None, + target_user_ids: Annotated[ + str | None, + "A comma-separated list of user IDs to open or resume a conversation. Provide 1 to 8 IDs. Supplying 1 ID opens a 1:1 DM, while more than 1 ID opens a multi-person DM. Do not include the caller's ID.", # noqa: E501 + ] = None, + return_full_im_channel_definition: Annotated[ + bool | None, + "Set to true to receive the entire IM channel definition; false returns only the conversation ID.", # noqa: E501 + ] = None, + prevent_creation: Annotated[ + bool | None, + "If true, does not create a new conversation and instead checks for an existing DM or MPDM.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'conversations.open'."]: + """Open or resume a direct or multi-person message in Slack. + + This tool calls the Slack API to open a new conversation or resume an existing direct message or multi-person direct message. It should be used when there's a need to start or continue a conversation within Slack.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/conversations.open", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "channel": conversation_channel_id, + "return_im": return_full_im_channel_definition, + "users": target_user_ids, + "prevent_creation": prevent_creation, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool( + requires_auth=OAuth2( + id="arcade-slack", + scopes=["channels:history", "groups:history", "im:history", "mpim:history"], + ) +) +async def get_slack_thread_messages( + context: ToolContext, + conversation_id: Annotated[ + str, "The ID of the Slack conversation from which to fetch the message thread." + ], + thread_message_timestamp: Annotated[ + str, + "Unique identifier of a parent message or a thread message (timestamp). Fetches the thread or the single message.", # noqa: E501 + ], + pagination_cursor: Annotated[ + str | None, + "Cursor for pagination. Use the `next_cursor` from a previous response to fetch the next page of data.", # noqa: E501 + ] = None, + latest_message_timestamp: Annotated[ + str | None, + "Only include messages posted before this Unix timestamp in the results. (default: 'now')", + ] = None, + maximum_items_to_return: Annotated[ + int | None, + "Specify the maximum number of messages to fetch. The default and maximum are 15 for certain apps, with possible rate limits. (default: '1000')", # noqa: E501 + ] = None, + start_time_unix_timestamp: Annotated[ + str | None, "Only include messages after this Unix timestamp in results. (default: '0')" + ] = None, + include_all_message_metadata: Annotated[ + bool | None, "Set to true to return all metadata associated with this message." + ] = None, + include_boundary_timestamps: Annotated[ + bool | None, + "Include messages with 'oldest' or 'latest' timestamps. Ignored unless either timestamp is specified.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'conversations.replies'."]: + """Retrieve messages from a Slack conversation thread. + + This tool fetches a thread of messages posted to a specific conversation in Slack. It should be called when there is a need to review or analyze the message history of a public or private channel, a direct message, or a multi-party direct message. The tool requires appropriate OAuth scopes to access the message history.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/conversations.replies", + params=remove_none_values({ + "channel": conversation_id, + "ts": thread_message_timestamp, + "cursor": pagination_cursor, + "include_all_metadata": include_all_message_metadata, + "inclusive": include_boundary_timestamps, + "latest": latest_message_timestamp, + "limit": maximum_items_to_return, + "oldest": start_time_unix_timestamp, + }), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["conversations.connect:manage"])) +async def deny_shared_invite_request( + context: ToolContext, + shared_channel_invite_id: Annotated[ + str, + "The ID for the shared channel invite request that you intend to deny. This is required for specifying which invite to decline.", # noqa: E501 + ], + deny_invite_message: Annotated[ + str | None, + "An optional message explaining why the invitation was denied. This message will be sent to the requester.", # noqa: E501 + ] = None, +) -> Annotated[ + dict[str, Any], "Response from the API endpoint 'conversations.requestSharedInvite.deny'." +]: + """Denies an external user invitation to a Slack channel. + + Use this tool to deny a request that invites an external user to join a Slack channel. It should be called when such an invite needs to be rejected.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/conversations.requestSharedInvite.deny", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "invite_id": shared_channel_invite_id, + "message": deny_invite_message, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["emoji:read"])) +async def list_custom_emoji_for_team( + context: ToolContext, + include_emoji_categories: Annotated[ + bool | None, "Set to true to include categories for Unicode emojis in the response." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'emoji.list'."]: + """Retrieve a list of custom emojis for a specific team. + + Use this tool to get a list of custom emojis available for a team on Slack. It should be called when you need to display or manage team-specific emojis.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/emoji.list", + params=remove_none_values({"include_categories": include_emoji_categories}), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["files:write"])) +async def get_external_file_upload_url( + context: ToolContext, + file_size_in_bytes: Annotated[ + int, + "Specify the size of the file to be uploaded, measured in bytes. Ensure this value accurately reflects the file size.", # noqa: E501 + ], + file_name: Annotated[str, "The name of the file to be uploaded to Slack."], + snippet_syntax_type: Annotated[ + str | None, + "Specify the syntax highlighting type for the snippet being uploaded, such as 'javascript', 'python', etc.", # noqa: E501 + ] = None, + alt_text_description: Annotated[ + str | None, "A description of the image for screen-readers, limited to 1000 characters." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'files.getUploadURLExternal'."]: + """Retrieve a URL to upload an external file to Slack. + + This tool is used to obtain a URL for uploading files externally to Slack, requiring the 'files:write' OAuth scope.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/files.getUploadURLExternal", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "length": file_size_in_bytes, + "filename": file_name, + "snippet_type": snippet_syntax_type, + "alt_txt": alt_text_description, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["remote_files:read"])) +async def get_remote_file_info_slack( + context: ToolContext, + file_external_identifier: Annotated[ + str | None, + "The GUID defined by the creator for the remote file to retrieve its information.", + ] = None, + file_id: Annotated[ + str | None, + "The unique identifier of the file to retrieve information about. Use this to specify the file in Slack.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'files.remote.info'."]: + """Retrieve details about a remote file from Slack. + + Use this tool to get information about a remote file that has been added to Slack. It is useful when you need details regarding the file, such as its metadata or status within Slack.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/files.remote.info", + params=remove_none_values({"external_id": file_external_identifier, "file": file_id}), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["remote_files:read"])) +async def get_slack_remote_files_info( + context: ToolContext, + filter_by_channel_id: Annotated[ + str | None, + "Filter remote files to only include those appearing in the specified Slack channel, indicated by its channel ID.", # noqa: E501 + ] = None, + pagination_cursor: Annotated[ + str | None, + "A cursor for paginating through data. Use the `next_cursor` from a prior request to fetch the next set of results. Defaults to the first page if not set.", # noqa: E501 + ] = None, + maximum_items_to_return: Annotated[ + int | None, "Specify the maximum number of remote file records to retrieve from Slack." + ] = None, + filter_files_from_timestamp: Annotated[ + str | None, + "Filter files created after this inclusive timestamp. Use a Unix timestamp format. (default: '0')", # noqa: E501 + ] = None, + timestamp_filter_end: Annotated[ + str | None, + "Filter files created before this timestamp (inclusive) in Unix epoch time format. (default: 'now')", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'files.remote.list'."]: + """Retrieve information about remote files added to Slack. + + This tool fetches details about remote files stored in Slack. It is useful when you need to access metadata for files that have been added to Slack from external sources.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/files.remote.list", + params=remove_none_values({ + "channel": filter_by_channel_id, + "cursor": pagination_cursor, + "limit": maximum_items_to_return, + "ts_from": filter_files_from_timestamp, + "ts_to": timestamp_filter_end, + }), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["remote_files:share"])) +async def share_remote_file_in_channel( + context: ToolContext, + target_channel_ids: Annotated[ + str, + "Comma-separated list of Slack channel IDs where the remote file will be shared. Ensure IDs are valid and the user has permission to share files in these channels.", # noqa: E501 + ], + file_external_identifier: Annotated[ + str | None, + "The globally unique identifier (GUID) for the file set by the app when registering with Slack. Required if 'file' is not provided.", # noqa: E501 + ] = None, + file_id: Annotated[ + str | None, + "The ID of a file registered with Slack to be shared. Required if `external_id` is not provided.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'files.remote.share'."]: + """Share a remote file into a Slack channel. + + This tool shares a specified remote file into a selected Slack channel. It utilizes Slack's API to facilitate file sharing across channels.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/files.remote.share", + params=remove_none_values({ + "channels": target_channel_ids, + "external_id": file_external_identifier, + "file": file_id, + }), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["files:write"])) +async def enable_slack_file_sharing( + context: ToolContext, + file_id_to_share: Annotated[ + str, "The ID of the file on Slack that you want to enable for public sharing." + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'files.sharedPublicURL'."]: + """Enable a Slack file for public sharing. + + This tool enables a file for public or external sharing on Slack using the Slack API. It should be called when a user wants to share a file publicly outside their Slack workspace.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/files.sharedPublicURL", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({"file": file_id_to_share}), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["pins:write"])) +async def pin_item_to_slack_channel( + context: ToolContext, + channel_id: Annotated[ + str, + "The ID of the Slack channel where the message will be pinned. A `timestamp` must also be provided.", # noqa: E501 + ], + message_timestamp: Annotated[ + str | None, + "The timestamp (`ts`) of the message to pin in the Slack channel. Ensure the channel is also specified.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'pins.add'."]: + """Pin an item to a Slack channel. + + Use this tool to pin an item to a specific channel in Slack, enhancing visibility for important content.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/pins.add", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({"channel": channel_id, "timestamp": message_timestamp}), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["pins:read"])) +async def list_pinned_items( + context: ToolContext, + channel_id: Annotated[ + str, + "The ID of the Slack channel to retrieve pinned items from. This is required to specify which channel's pinned items will be listed.", # noqa: E501 + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'pins.list'."]: + """Retrieve items pinned to a Slack channel. + + This tool calls the Slack API to list all items pinned to a specific channel. It should be used when there is a need to display or manage pinned items in a Slack channel.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/pins.list", + params=remove_none_values({"channel": channel_id}), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["reactions:write"])) +async def add_slack_reaction( + context: ToolContext, + slack_channel_id: Annotated[ + str, + "ID of the channel where the message is posted. Use to specify the location for adding a reaction.", # noqa: E501 + ], + reaction_emoji_name: Annotated[ + str, + "The name of the emoji to be used as a reaction. Include skin tone modifiers if applicable (e.g., 'thumbsup::skin-tone-2').", # noqa: E501 + ], + message_timestamp: Annotated[ + str, + "The timestamp of the message to which the reaction will be added. Ensure the format matches the Slack API requirements.", # noqa: E501 + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'reactions.add'."]: + """Add a reaction to a Slack item. + + Use this tool to add an emoji reaction to a message or item within Slack. This can be useful for acknowledging messages or express sentiments quickly.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/reactions.add", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "channel": slack_channel_id, + "name": reaction_emoji_name, + "timestamp": message_timestamp, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["reactions:write"])) +async def remove_reaction_from_item( + context: ToolContext, + reaction_emoji_name: Annotated[ + str, "The name of the emoji reaction to be removed, such as 'smile' or 'thumbsup'." + ], + target_file_id: Annotated[ + str | None, + "The identifier of the file from which to remove the reaction. Specify either this, `target_file_comment_id`, or both `target_channel_id` and `target_message_timestamp`.", # noqa: E501 + ] = None, + file_comment_id: Annotated[ + str | None, + "The ID of the file comment from which you want to remove the reaction. Provide this if the reaction is on a file comment.", # noqa: E501 + ] = None, + message_channel_id: Annotated[ + str | None, + "Channel ID where the message to remove the reaction from was posted. Required if removing a reaction from a message. Use in combination with 'message_timestamp'.", # noqa: E501 + ] = None, + message_timestamp: Annotated[ + str | None, + "The exact timestamp of the message from which to remove the reaction. Specify when targeting a message.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'reactions.remove'."]: + """Remove a reaction from a Slack item. + + Use this tool to remove a reaction (emoji) from a message, file, or file comment in Slack. This tool is intended for situations where a reaction needs to be revoked. It requires the 'reactions:write' scope, which allows the app to manage reactions on behalf of the user.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/reactions.remove", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "name": reaction_emoji_name, + "file": target_file_id, + "file_comment": file_comment_id, + "channel": message_channel_id, + "timestamp": message_timestamp, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["search:read"])) +async def search_files_in_slack( + context: ToolContext, + search_query: Annotated[ + str, + "The text string to search for in Slack files. Use keywords or phrases to narrow down results.", # noqa: E501 + ], + items_per_page: Annotated[ + int | None, + "The number of file results to return per page. Maximum allowed value is 100. (default: '20')", # noqa: E501 + ] = None, + results_page_number: Annotated[ + int | None, + "The specific page number of results to retrieve, with a maximum value of 100. (default: '1')", # noqa: E501 + ] = None, + sort_files_by: Annotated[ + str | None, + "Specify how to sort the search results: either by 'score' or 'timestamp'. (default: 'score')", # noqa: E501 + ] = None, + sort_direction: Annotated[ + str | None, + "Change the sort direction for search results to ascending ('asc') or descending ('desc'). (default: 'desc')", # noqa: E501 + ] = None, + encoded_team_id: Annotated[ + str | None, + "Encoded team ID to specify the search domain when using an org-level token. Ignored with a workspace-level token.", # noqa: E501 + ] = None, + enable_query_highlight: Annotated[ + bool | None, + "Set to true to enable highlight markers for matching query terms in the search results.", + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'search.files'."]: + """Search for files in Slack using a query. + + This tool searches for files in Slack that match a given query. It is useful when a user needs to locate specific files shared in Slack channels or direct messages. The tool returns a list of files that meet the search criteria.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/search.files", + params=remove_none_values({ + "query": search_query, + "count": items_per_page, + "highlight": enable_query_highlight, + "page": results_page_number, + "sort": sort_files_by, + "sort_dir": sort_direction, + "team_id": encoded_team_id, + }), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["search:read"])) +async def search_slack_messages( + context: ToolContext, + search_query: Annotated[ + str, + "The text to search for in Slack messages. Use keywords or phrases to narrow down results.", + ], + results_per_page: Annotated[ + int | None, + "The number of search results to return per page, with a maximum limit of 100. (default: '20')", # noqa: E501 + ] = None, + page_number: Annotated[ + int | None, + "The page number of search results to retrieve, maximum value of 100. (default: '1')", + ] = None, + pagination_cursor: Annotated[ + str | None, + "Use '*' for the first call to start pagination or provide the 'next_cursor' value from previous results to continue.", # noqa: E501 + ] = None, + sort_results_by: Annotated[ + str | None, + "Specify the criterion for sorting the search results, either by 'score' for relevance or 'timestamp' for chronological order. (default: 'score')", # noqa: E501 + ] = None, + sort_direction: Annotated[ + str | None, + "Specify the order for sorting results: use 'asc' for ascending or 'desc' for descending. (default: 'desc')", # noqa: E501 + ] = None, + team_id: Annotated[ + str | None, + "The encoded team ID to search within. Required only if an organization-level token is used. Ignored for workspace-level tokens.", # noqa: E501 + ] = None, + enable_query_highlighting: Annotated[ + bool | None, + "Set to true to enable query highlight markers, marking matching terms in the results.", + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'search.messages'."]: + """Search Slack messages based on a query. + + This tool searches for messages in a Slack workspace that match a specified query. It should be called when users want to find specific messages or discussions within their Slack channels.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/search.messages", + params=remove_none_values({ + "query": search_query, + "count": results_per_page, + "highlight": enable_query_highlighting, + "page": page_number, + "cursor": pagination_cursor, + "sort": sort_results_by, + "sort_dir": sort_direction, + "team_id": team_id, + }), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["admin"])) +async def get_team_billable_users_info( + context: ToolContext, + pagination_cursor: Annotated[ + str | None, + "Cursor for pagination. Use the `next_cursor` from the previous response to fetch the next page of users. (default: 'fetches the first page')", # noqa: E501 + ] = None, + maximum_items_to_return: Annotated[ + int | None, "Specifies the maximum number of billable user entries to be retrieved." + ] = None, + specific_user_id: Annotated[ + str | None, + "The ID of a specific user to retrieve billable information for. Leave empty to retrieve info for all users.", # noqa: E501 + ] = None, + encoded_team_id: Annotated[ + str | None, + "Encoded team ID for retrieving billable info, required if using an org token. Ignored with workspace-level tokens.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'team.billableInfo'."]: + """Retrieves billable users info for the current Slack team. + + Use this tool to obtain information about billable users in your Slack team. It requires administrative privileges with the 'admin' scope.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/team.billableInfo", + params=remove_none_values({ + "cursor": pagination_cursor, + "limit": maximum_items_to_return, + "user": specific_user_id, + "team_id": encoded_team_id, + }), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["team:read"])) +async def get_current_slack_team_info( + context: ToolContext, + query_by_domain: Annotated[ + str | None, + "Comma-separated domains to query instead of a team, used when the team is not specified. This only works for domains in the same enterprise as the querying team token.", # noqa: E501 + ] = None, + specific_team_id: Annotated[ + str | None, + "The ID of the Slack team to retrieve information about. If omitted, information about the current team will be returned.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'team.info'."]: + """Retrieve information about the current Slack team. + + This tool is used to get information about the current Slack team, including settings and general details. It is called when there's a need to access team information in a Slack workspace.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/team.info", + params=remove_none_values({"domain": query_by_domain, "team": specific_team_id}), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["admin"])) +async def get_integration_logs( + context: ToolContext, + filter_by_app_id: Annotated[ + str | None, + "Filter integration logs to a specific Slack app. If not provided, logs for all apps are retrieved.", # noqa: E501 + ] = None, + filter_by_change_type: Annotated[ + str | None, + "Specify the change type to filter logs. Options: 'added', 'removed', 'enabled', 'disabled', 'updated'. Defaults to all logs.", # noqa: E501 + ] = None, + result_count: Annotated[ + str | None, + "The number of log entries to retrieve. Specify the maximum number of logs to return in a single request. (default: '100')", # noqa: E501 + ] = None, + result_page_number: Annotated[ + str | None, + "The specific page number of the integration logs to retrieve. Used for pagination. (default: '1')", # noqa: E501 + ] = None, + filter_by_service_id: Annotated[ + str | None, + "Specify the service ID to filter integration logs related to a specific service. If not provided, logs for all services will be retrieved.", # noqa: E501 + ] = None, + encoded_team_id: Annotated[ + str | None, + "The encoded team ID to get logs from, required if using an org-level token. Ignored if using a workspace-level token.", # noqa: E501 + ] = None, + filter_by_user: Annotated[ + str | None, + "Filter logs generated by a specific user's actions. Defaults to all logs if not specified.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'team.integrationLogs'."]: + """Retrieve integration logs for the current Slack team. + + This tool retrieves the integration logs for the current Slack team, providing insights into the team's integration history and activities. It requires admin OAuth scope to access the logs.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/team.integrationLogs", + params=remove_none_values({ + "app_id": filter_by_app_id, + "change_type": filter_by_change_type, + "count": result_count, + "page": result_page_number, + "service_id": filter_by_service_id, + "team_id": encoded_team_id, + "user": filter_by_user, + }), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["team.preferences:read"])) +async def get_slack_team_preferences( + context: ToolContext, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'team.preferences.list'."]: + """Retrieve a list of a workspace's team preferences. + + This tool fetches team preferences from a Slack workspace. It should be called when there's a need to access or review team settings. Requires appropriate OAuth scope for access.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/team.preferences.list", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["users.profile:read"])) +async def get_team_profile( + context: ToolContext, + visibility_filter: Annotated[ + str | None, + "Filter the profile fields based on visibility. Options: 'all', 'visible', 'hidden'. Default is 'all'.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'team.profile.get'."]: + """Retrieve a team's profile information from Slack. + + This tool retrieves a team's profile from Slack. It should be called when there's a need to access team information such as members, roles, or other relevant details. The tool uses the Slack API and requires the 'users.profile:read' OAuth scope.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/team.profile.get", + params=remove_none_values({"visibility": visibility_filter}), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["usergroups:write"])) +async def create_slack_user_group( + context: ToolContext, + user_group_name: Annotated[ + str, + "A unique name for the user group to be created, distinguishing it from other user groups.", + ], + default_channel_ids: Annotated[ + list[str] | None, + "A list of channel IDs to set as default for the User Group. Use comma-separated values.", + ] = None, + custom_additional_channels: Annotated[ + list[str] | None, + "Comma-separated encoded channel IDs where the User Group can add members.", + ] = None, + user_group_description: Annotated[ + str | None, "A brief text describing the purpose or role of the user group in Slack." + ] = None, + unique_mention_handle: Annotated[ + str | None, + "A unique mention handle for the user group. It must not duplicate existing handles of channels, users, or other user groups.", # noqa: E501 + ] = None, + team_id_for_user_group_creation: Annotated[ + str | None, + "Encoded team ID for the user group creation, required if using an org-level token.", + ] = None, + include_user_count: Annotated[ + bool | None, "Set to true to include the number of users in each User Group." + ] = None, + enable_display_as_sidebar_section: Annotated[ + bool | None, + "Set to true to display the user group as a sidebar section for all group members if the group has one or more default channels.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'usergroups.create'."]: + """Creates a new user group in Slack. + + This tool allows the creation of a new user group in Slack using the Slack API. It should be called when you need to organize users into groups for easier management or communication. Requires 'usergroups:write' scope.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/usergroups.create", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "name": user_group_name, + "channels": default_channel_ids, + "additional_channels": custom_additional_channels, + "description": user_group_description, + "handle": unique_mention_handle, + "include_count": include_user_count, + "team_id": team_id_for_user_group_creation, + "enable_section": enable_display_as_sidebar_section, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["usergroups:write"])) +async def disable_user_group( + context: ToolContext, + user_group_id: Annotated[str, "The encoded ID of the User Group to be disabled."], + team_id: Annotated[ + str | None, + "Encoded target team ID where the user group exists. Required only if using an org-level token; ignored for workspace-level tokens.", # noqa: E501 + ] = None, + include_user_count: Annotated[ + bool | None, + "Include the number of users in the User Group. Set to true to include the count.", + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'usergroups.disable'."]: + """Disable an existing Slack User Group. + + This tool should be called to disable an existing User Group in Slack. It requires appropriate OAuth scopes and sends a POST request to the Slack API. Use this tool when you need to deactivate a User Group to prevent users from being able to reference or use it.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/usergroups.disable", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "usergroup": user_group_id, + "include_count": include_user_count, + "team_id": team_id, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["usergroups:write"])) +async def enable_slack_user_group( + context: ToolContext, + user_group_id: Annotated[str, "The encoded ID of the User Group to be enabled in Slack."], + team_id: Annotated[ + str | None, + "Provide the encoded team ID where the user group is located. Only required if using an org-level token. Ignored with workspace-level tokens.", # noqa: E501 + ] = None, + include_user_count: Annotated[ + bool | None, "Set to true to include the number of users in the User Group." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'usergroups.enable'."]: + """Enable a user group in Slack. + + This tool activates a specified user group in Slack. It should be called when an action is needed to enable a user group so that it can be used within Slack for communication or organizational purposes. This tool is particularly useful for managing Slack user groups efficiently.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/usergroups.enable", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "usergroup": user_group_id, + "include_count": include_user_count, + "team_id": team_id, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["usergroups:read"])) +async def list_slack_user_groups( + context: ToolContext, + team_id_for_org_token: Annotated[ + str | None, + "Encoded team ID required when using an org-level token. Ignored if using a workspace-level token.", # noqa: E501 + ] = None, + include_user_count: Annotated[ + bool | None, "Set to true to include the number of users in each User Group." + ] = None, + include_disabled_groups: Annotated[ + bool | None, "Set to true to include disabled user groups in the results." + ] = None, + include_users_in_group: Annotated[ + bool | None, "Include the list of users for each User Group in the response." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'usergroups.list'."]: + """Retrieve all user groups for a Slack team. + + This tool retrieves a list of all user groups available in a Slack team. It should be called when there's a need to access or display user group information within a Slack workspace.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/usergroups.list", + params=remove_none_values({ + "include_count": include_user_count, + "include_disabled": include_disabled_groups, + "include_users": include_users_in_group, + "team_id": team_id_for_org_token, + }), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["usergroups:write"])) +async def update_slack_user_group( + context: ToolContext, + user_group_id: Annotated[str, "The encoded ID of the User Group to update in Slack."], + default_channel_ids: Annotated[ + list[str] | None, + "A comma-separated list of channel IDs where the User Group is set as default. Use encoded channel IDs.", # noqa: E501 + ] = None, + additional_channel_ids: Annotated[ + list[str] | None, + "Comma separated encoded channel IDs for custom additions to user group members.", + ] = None, + user_group_description: Annotated[ + str | None, + "A short description of the User Group to update in Slack. This should clearly define the group's purpose or role.", # noqa: E501 + ] = None, + user_group_handle: Annotated[ + str | None, + "Unique mention handle for the User Group, distinct from all channels, users, and other User Groups.", # noqa: E501 + ] = None, + user_group_name: Annotated[ + str | None, + "A unique name for the User Group to update. Ensure it does not duplicate any existing User Group names.", # noqa: E501 + ] = None, + team_id_for_org_token: Annotated[ + str | None, + "Encoded team ID where the user group exists, required for org-level tokens. Ignored if using a workspace-level token.", # noqa: E501 + ] = None, + include_user_count: Annotated[ + bool | None, "Set to true to include the number of users in the User Group." + ] = None, + enable_sidebar_section: Annotated[ + bool | None, + "Set to true to configure the user group to appear as a sidebar section for all group members. Only relevant if the group has 1 or more default channels.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'usergroups.update'."]: + """Update an existing User Group in Slack. + + This tool updates an existing User Group in Slack. It should be called when you need to modify the details of a user group, such as its name or permissions. Ensure the appropriate permissions are granted with the 'usergroups:write' scope.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/usergroups.update", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "usergroup": user_group_id, + "channels": default_channel_ids, + "additional_channels": additional_channel_ids, + "description": user_group_description, + "handle": user_group_handle, + "include_count": include_user_count, + "name": user_group_name, + "team_id": team_id_for_org_token, + "enable_section": enable_sidebar_section, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["usergroups:write"])) +async def update_slack_usergroup_users( + context: ToolContext, + user_group_id: Annotated[str, "The encoded ID of the Slack user group to update."], + user_ids_list: Annotated[ + list[str], + "A comma separated string of encoded Slack user IDs representing the complete user list for the group. This replaces all current members.", # noqa: E501 + ], + team_id_for_org_token: Annotated[ + str | None, + "Encoded team ID where the user group exists. Required if using an organization token; ignored with workspace-level token.", # noqa: E501 + ] = None, + update_additional_channels: Annotated[ + list[str] | None, + "Encoded channel IDs to add user group members to, separated by commas. These represent additional channels for custom user group member additions.", # noqa: E501 + ] = None, + include_user_count: Annotated[ + bool | None, "Set to true to include the number of users in the user group in the response." + ] = None, + is_shared_section: Annotated[ + bool | None, + "Indicates if the API call involves a shared section. Set to true if it does, otherwise false.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'usergroups.users.update'."]: + """Update the list of users in a Slack user group. + + This tool updates the list of users for a specified Slack user group. It should be called when changes to the membership of a Slack user group are required.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/usergroups.users.update", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "usergroup": user_group_id, + "users": user_ids_list, + "include_count": include_user_count, + "team_id": team_id_for_org_token, + "additional_channels": update_additional_channels, + "is_shared": is_shared_section, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool( + requires_auth=OAuth2( + id="arcade-slack", scopes=["channels:read", "groups:read", "im:read", "mpim:read"] + ) +) +async def list_accessible_slack_conversations( + context: ToolContext, + pagination_cursor: Annotated[ + str | None, + "A cursor for pagination to continue listing conversations from a specific point. Use the 'next_cursor' from a previous response. Default is the first page.", # noqa: E501 + ] = None, + maximum_items_to_return: Annotated[ + int | None, + "The maximum number of conversations to return in the response. Must be an integer with a maximum value of 999. It is recommended to request no more than 200 results at a time for optimal performance. (default: '100')", # noqa: E501 + ] = None, + slack_team_id: Annotated[ + str | None, + "The encoded ID of the Slack team to list conversations for. Required if using an organization-level token. Ignored if a workspace-level token is used.", # noqa: E501 + ] = None, + channel_types: Annotated[ + str | None, + "Comma-separated list of channel types to filter conversations. Options: public_channel, private_channel, mpim, im. (default: 'public_channel')", # noqa: E501 + ] = None, + specific_user_id: Annotated[ + str | None, + "Filter conversations by a specific user ID's membership. Only includes conversations shared with the calling user.", # noqa: E501 + ] = None, + exclude_archived_channels: Annotated[ + bool | None, + "Set to true to exclude archived channels from the retrieved list of Slack conversations. (default: false)", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'users.conversations'."]: + """Retrieve a list of conversations the user can access on Slack. + + This tool calls the Slack API to list all conversations (public channels, private channels, direct messages) that a user has access to. It can be used to view information about different types of conversations including public channels, private channels, and direct or group messages.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/users.conversations", + params=remove_none_values({ + "cursor": pagination_cursor, + "exclude_archived": exclude_archived_channels, + "limit": maximum_items_to_return, + "team_id": slack_team_id, + "types": channel_types, + "user": specific_user_id, + }), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["conversations.connect:manage", "team:read"])) +async def check_slack_discoverability( + context: ToolContext, + email_to_check: Annotated[ + str, "The email address to verify if it is associated with a discoverable Slack user." + ], +) -> Annotated[ + dict[str, Any], "Response from the API endpoint 'users.discoverableContacts.lookup'." +]: + """Check if an email is discoverable on Slack. + + Use this tool to determine if an email address is associated with a discoverable Slack user. It should be called when needing to verify Slack user discoverability by email.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/users.discoverableContacts.lookup", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({"email": email_to_check}), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["users:read"])) +async def get_slack_user_presence( + context: ToolContext, + target_user_id: Annotated[ + str | None, + "The Slack user ID for which you want to retrieve presence information. (default: 'authed user')", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'users.getPresence'."]: + """Retrieve user presence information from Slack. + + Use this tool to get the presence status of a user on Slack, indicating whether they are active or away.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/users.getPresence", + params=remove_none_values({"user": target_user_id}), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["identity.read", "identity.basic"])) +async def get_user_identity( + context: ToolContext, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'users.identity'."]: + """Retrieve a user's identity information from Slack. + + This tool is used to get detailed information about a user's identity on Slack. It should be called when user identity details are required, such as for authentication purposes or to display user information within an application leveraging Slack's API.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/users.identity", + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["users:read", "users:read.email"])) +async def list_slack_team_users( + context: ToolContext, + pagination_cursor: Annotated[ + str | None, + "Cursor for paginating through data. Use the `next_cursor` from a previous response to continue.", # noqa: E501 + ] = None, + maximum_items_to_return: Annotated[ + int | None, "Maximum number of users to return (recommended max is 200 for pagination)." + ] = None, + slack_team_id: Annotated[ + str | None, + "The encoded team ID to list users from, necessary if an organization-level token is used. Ignored if a workspace-level token is provided.", # noqa: E501 + ] = None, + include_user_locale: Annotated[ + bool | None, "Set to true to receive locale information for each user. Default is false." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'users.list'."]: + """Fetches a list of all users in a Slack team. + + This tool retrieves a comprehensive list of all users within a specified Slack team. It includes user details and can access email information if the appropriate OAuth scopes are provided.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/users.list", + params=remove_none_values({ + "cursor": pagination_cursor, + "include_locale": include_user_locale, + "limit": maximum_items_to_return, + "team_id": slack_team_id, + }), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["users:read.email"])) +async def find_slack_user_by_email( + context: ToolContext, + user_email_address: Annotated[ + str, "The email address of the user in the Slack workspace to search for." + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'users.lookupByEmail'."]: + """Find a Slack user using their email address. + + This tool allows you to search for a Slack user by their email address. It should be called when you need to retrieve user information based on email within Slack.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/users.lookupByEmail", + params=remove_none_values({"email": user_email_address}), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["users.profile:read", "users:read.email"])) +async def get_slack_user_profile( + context: ToolContext, + target_user_id: Annotated[ + str | None, + "The unique identifier of the Slack user whose profile information is to be retrieved.", + ] = None, + include_labels: Annotated[ + bool | None, + "Include labels for each ID in custom profile fields. This option can heavily rate-limit requests and is not recommended. Default is false.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'users.profile.get'."]: + """Retrieve Slack user profile information and custom status. + + This tool fetches the profile information of a Slack user, including their custom status and email (if authorized). It requires appropriate read scopes (users.profile:read or users:read.email).""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/users.profile.get", + params=remove_none_values({"include_labels": include_labels, "user": target_user_id}), + method="GET", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_auth=OAuth2(id="arcade-slack", scopes=["users.profile:write"])) +async def set_slack_profile_photo( + context: ToolContext, + crop_box_size: Annotated[ + str | None, + "The size of the square crop box for the profile photo in pixels. Specify the width and height, which are the same value for a square.", # noqa: E501 + ] = None, + crop_box_x_coordinate: Annotated[ + str | None, "X coordinate of the top-left corner of the crop box for the profile photo." + ] = None, + crop_y_coordinate: Annotated[ + str | None, + "Y coordinate of the top-left corner of the crop box for the user's profile photo on Slack. This determines where the cropping of the image will start on the vertical axis.", # noqa: E501 + ] = None, + profile_photo_image: Annotated[ + str | None, + "The image file to set as the Slack profile photo. Provide image data directly with the correct content type (e.g., image/jpeg, image/png).", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'users.setPhoto'."]: + """Set the user's profile photo on Slack. + + Use this tool to update a user's profile photo on Slack. This requires the 'users.profile:write' OAuth scope, allowing changes to profile information including the profile photo.""" # noqa: E501 + async with httpx.AsyncClient() as client: + response = await client.request( + url="https://slack.com/api/users.setPhoto", + method="POST", + headers=remove_none_values({ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Bearer {authorization}".format( # noqa: UP032 + authorization=context.get_auth_token_or_empty() + ), + }), + data=remove_none_values({ + "crop_w": crop_box_size, + "crop_x": crop_box_x_coordinate, + "crop_y": crop_y_coordinate, + "image": profile_photo_image, + }), + ) + response.raise_for_status() + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/AcceptSlackInvite.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/AcceptSlackInvite.json new file mode 100644 index 00000000..87e77243 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/AcceptSlackInvite.json @@ -0,0 +1,269 @@ +{ + "name": "AcceptSlackInvite", + "fully_qualified_name": "SlackApi.AcceptSlackInvite@0.1.0", + "description": "Accept invitations to a Slack Connect channel.\n\nUse this tool to accept an invitation to a Slack Connect channel, facilitating seamless collaboration across different Slack workspaces.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "channel_name", + "required": true, + "description": "Provide the desired name for the Slack Connect channel. If the channel doesn't exist in your workspace, this name will be assigned to it.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel_name" + }, + { + "name": "invite_id", + "required": false, + "description": "ID of the invitation you want to accept. Must provide either this or channel_id.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "invite_id" + }, + { + "name": "slack_channel_id_to_accept", + "required": false, + "description": "The ID of the channel you would like to accept the invitation for. Either this or `invite_id` is required.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel_id" + }, + { + "name": "workspace_id", + "required": false, + "description": "The ID of the workspace where the channel should be accepted. Required if using an org-level token.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "is_channel_private", + "required": false, + "description": "True to make the channel private; false to make it public.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "is_private" + }, + { + "name": "use_free_trial", + "required": false, + "description": "Set to 'True' to use your workspace's free trial to start using Slack Connect.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "free_trial_accepted" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'conversations.acceptSharedInvite'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "conversations.connect:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/conversations.acceptSharedInvite", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel_name", + "tool_parameter_name": "channel_name", + "description": "Name of the channel. If the channel does not exist already in your workspace, this name is the one that the channel will take.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "is_private", + "tool_parameter_name": "is_channel_private", + "description": "Whether the channel should be private.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "free_trial_accepted", + "tool_parameter_name": "use_free_trial", + "description": "Whether you'd like to use your workspace's free trial to begin using Slack Connect.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "invite_id", + "tool_parameter_name": "invite_id", + "description": "ID of the invite that you\u2019d like to accept. Must provide either `invite_id` or `channel_id`. See the `shared_channel_invite_received` event payload for more details on how to retrieve the ID of the invitation.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "channel_id", + "tool_parameter_name": "slack_channel_id_to_accept", + "description": "ID of the channel that you'd like to accept. Must provide either `invite_id` or `channel_id`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "workspace_id", + "description": "The ID of the workspace to accept the channel in. If an org-level token is used to call this method, the `team_id` argument is required.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/conversations.acceptsharedinvite" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/AddCallParticipants.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/AddCallParticipants.json new file mode 100644 index 00000000..5b8d9bc6 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/AddCallParticipants.json @@ -0,0 +1,141 @@ +{ + "name": "AddCallParticipants", + "fully_qualified_name": "SlackApi.AddCallParticipants@0.1.0", + "description": "Add new participants to a Slack call.\n\nThis tool registers new participants to an existing call in Slack. It should be used when you want to add people to a call that is already in progress or scheduled. The tool ensures participants are correctly added using the appropriate Slack API scope.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "call_id", + "required": true, + "description": "The unique identifier for the call, as returned by the `calls.add` method. This ID specifies which call the participants will be added to.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "id" + }, + { + "name": "participant_users", + "required": true, + "description": "List of users to add, specified by `slack_id` or `external_id`. Include optional `display_name` and `avatar_url` for each user.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "users" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'calls.participants.add'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "calls:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/calls.participants.add", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "id", + "tool_parameter_name": "call_id", + "description": "`id` returned by the `calls.add` method.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "users", + "tool_parameter_name": "participant_users", + "description": "The list of users to add as participants in the Call.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/calls.participants.add" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/AddSlackEmojiAlias.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/AddSlackEmojiAlias.json new file mode 100644 index 00000000..d54272bc --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/AddSlackEmojiAlias.json @@ -0,0 +1,141 @@ +{ + "name": "AddSlackEmojiAlias", + "fully_qualified_name": "SlackApi.AddSlackEmojiAlias@0.1.0", + "description": "Add an emoji alias in a Slack Enterprise organization.\n\nThis tool calls the Slack API to add an alias for an emoji within a Slack Enterprise organization. It should be used when a user wants to create a new shortcut or name for an existing emoji. Requires appropriate admin permissions.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "emoji_alias_name", + "required": true, + "description": "The new alias for the specified emoji. Whitespace or colons will be automatically trimmed.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "name" + }, + { + "name": "target_emoji_name", + "required": true, + "description": "The name of the existing emoji to which the new alias is being added. Remove any surrounding whitespace or colons.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "alias_for" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'admin.emoji.addAlias'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "admin.teams:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/admin.emoji.addAlias", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "name", + "tool_parameter_name": "emoji_alias_name", + "description": "The new alias for the specified emoji. Any wrapping whitespace or colons will be automatically trimmed.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "alias_for", + "tool_parameter_name": "target_emoji_name", + "description": "Name of the emoji for which the alias is being made. Any wrapping whitespace or colons will be automatically trimmed.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/admin.emoji.addalias" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/AddSlackReaction.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/AddSlackReaction.json new file mode 100644 index 00000000..e826bfb8 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/AddSlackReaction.json @@ -0,0 +1,173 @@ +{ + "name": "AddSlackReaction", + "fully_qualified_name": "SlackApi.AddSlackReaction@0.1.0", + "description": "Add a reaction to a Slack item.\n\nUse this tool to add an emoji reaction to a message or item within Slack. This can be useful for acknowledging messages or express sentiments quickly.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "slack_channel_id", + "required": true, + "description": "ID of the channel where the message is posted. Use to specify the location for adding a reaction.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "reaction_emoji_name", + "required": true, + "description": "The name of the emoji to be used as a reaction. Include skin tone modifiers if applicable (e.g., 'thumbsup::skin-tone-2').", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "name" + }, + { + "name": "message_timestamp", + "required": true, + "description": "The timestamp of the message to which the reaction will be added. Ensure the format matches the Slack API requirements.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "timestamp" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'reactions.add'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "reactions:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/reactions.add", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "slack_channel_id", + "description": "Channel where the message to add reaction to was posted.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "name", + "tool_parameter_name": "reaction_emoji_name", + "description": "Reaction (emoji) name", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "timestamp", + "tool_parameter_name": "message_timestamp", + "description": "Timestamp of the message to add reaction to.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/reactions.add" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ApproveSlackChannelInvitation.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ApproveSlackChannelInvitation.json new file mode 100644 index 00000000..29eff728 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ApproveSlackChannelInvitation.json @@ -0,0 +1,141 @@ +{ + "name": "ApproveSlackChannelInvitation", + "fully_qualified_name": "SlackApi.ApproveSlackChannelInvitation@0.1.0", + "description": "Approve an invitation to a Slack Connect channel.\n\nThis tool is used to approve invitations sent to a Slack Connect channel, allowing collaboration between different Slack workspaces. It should be called when a user wants to manage and approve channel access invitations.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "shared_channel_invite_id", + "required": true, + "description": "The ID of the shared channel invitation you want to approve. It is required to specifically identify which invitation is being approved for the Slack Connect channel.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "invite_id" + }, + { + "name": "other_party_team_id", + "required": false, + "description": "The team or enterprise ID of the other party involved in the Slack Connect invitation you are approving.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "target_team" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'conversations.approveSharedInvite'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "conversations.connect:manage" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/conversations.approveSharedInvite", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "invite_id", + "tool_parameter_name": "shared_channel_invite_id", + "description": "ID of the shared channel invite to approve", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "target_team", + "tool_parameter_name": "other_party_team_id", + "description": "The team or enterprise id of the other party involved in the invitation you are approving", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/conversations.approvesharedinvite" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/CheckApiCallingCode.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/CheckApiCallingCode.json new file mode 100644 index 00000000..a950030b --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/CheckApiCallingCode.json @@ -0,0 +1,107 @@ +{ + "name": "CheckApiCallingCode", + "fully_qualified_name": "SlackApi.CheckApiCallingCode@0.1.0", + "description": "Verify the correctness of API calling code for Slack.\n\nThis tool verifies the accuracy and functionality of an API calling code by calling Slack's API testing endpoint. It's useful for developers who want to check if their code successfully interacts with Slack's API.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "simulate_error_response", + "required": false, + "description": "Specify an error code to simulate an error response for testing API calls. Useful for testing error handling.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "error" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'api.test'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/api.test", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "error", + "tool_parameter_name": "simulate_error_response", + "description": "Error response to return", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/api.test" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/CheckSlackDiscoverability.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/CheckSlackDiscoverability.json new file mode 100644 index 00000000..53d8efcf --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/CheckSlackDiscoverability.json @@ -0,0 +1,110 @@ +{ + "name": "CheckSlackDiscoverability", + "fully_qualified_name": "SlackApi.CheckSlackDiscoverability@0.1.0", + "description": "Check if an email is discoverable on Slack.\n\nUse this tool to determine if an email address is associated with a discoverable Slack user. It should be called when needing to verify Slack user discoverability by email.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "email_to_check", + "required": true, + "description": "The email address to verify if it is associated with a discoverable Slack user.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "email" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'users.discoverableContacts.lookup'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "conversations.connect:manage", + "team:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/users.discoverableContacts.lookup", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "email", + "tool_parameter_name": "email_to_check", + "description": "The email address to look up to see if someone is discoverable on Slack.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/users.discoverablecontacts.lookup" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/CreateSlackConversation.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/CreateSlackConversation.json new file mode 100644 index 00000000..84ebd270 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/CreateSlackConversation.json @@ -0,0 +1,177 @@ +{ + "name": "CreateSlackConversation", + "fully_qualified_name": "SlackApi.CreateSlackConversation@0.1.0", + "description": "Create a new public or private Slack conversation.\n\nThis tool is used to initiate a new conversation channel in Slack, allowing for the creation of either public or private channels. It is useful when setting up new communication threads within a team or project.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "channel_name", + "required": true, + "description": "The name of the new Slack channel to create. It must contain only lowercase letters, numbers, hyphens, and underscores, and be 80 characters or less.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "name" + }, + { + "name": "encoded_team_id", + "required": false, + "description": "The encoded team ID where the channel will be created. Required when using an organization-level token. Ignored if using a workspace-level token.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "create_private_channel", + "required": false, + "description": "Set to true to create a private channel instead of a public one.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "is_private" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'conversations.create'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "channels:manage", + "channels:write", + "groups:write", + "im:write", + "mpim:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/conversations.create", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "name", + "tool_parameter_name": "channel_name", + "description": "Name of the public or private channel to create", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "is_private", + "tool_parameter_name": "create_private_channel", + "description": "Create a private channel instead of a public one", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "encoded_team_id", + "description": "Encoded team id to create the channel in, required if org token is used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/conversations.create" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/CreateSlackUserGroup.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/CreateSlackUserGroup.json new file mode 100644 index 00000000..90cbccd6 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/CreateSlackUserGroup.json @@ -0,0 +1,333 @@ +{ + "name": "CreateSlackUserGroup", + "fully_qualified_name": "SlackApi.CreateSlackUserGroup@0.1.0", + "description": "Creates a new user group in Slack.\n\nThis tool allows the creation of a new user group in Slack using the Slack API. It should be called when you need to organize users into groups for easier management or communication. Requires 'usergroups:write' scope.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "user_group_name", + "required": true, + "description": "A unique name for the user group to be created, distinguishing it from other user groups.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "name" + }, + { + "name": "default_channel_ids", + "required": false, + "description": "A list of channel IDs to set as default for the User Group. Use comma-separated values.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channels" + }, + { + "name": "custom_additional_channels", + "required": false, + "description": "Comma-separated encoded channel IDs where the User Group can add members.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "additional_channels" + }, + { + "name": "user_group_description", + "required": false, + "description": "A brief text describing the purpose or role of the user group in Slack.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "description" + }, + { + "name": "unique_mention_handle", + "required": false, + "description": "A unique mention handle for the user group. It must not duplicate existing handles of channels, users, or other user groups.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "handle" + }, + { + "name": "team_id_for_user_group_creation", + "required": false, + "description": "Encoded team ID for the user group creation, required if using an org-level token.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "include_user_count", + "required": false, + "description": "Set to true to include the number of users in each User Group.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_count" + }, + { + "name": "enable_display_as_sidebar_section", + "required": false, + "description": "Set to true to display the user group as a sidebar section for all group members if the group has one or more default channels.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "enable_section" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'usergroups.create'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "usergroups:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/usergroups.create", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "name", + "tool_parameter_name": "user_group_name", + "description": "A name for the User Group. Must be unique among User Groups.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "channels", + "tool_parameter_name": "default_channel_ids", + "description": "A comma separated string of encoded channel IDs for which the User Group uses as a default.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "additional_channels", + "tool_parameter_name": "custom_additional_channels", + "description": "A comma separated string of encoded channel IDs for which the User Group can custom add usergroup members too.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "description", + "tool_parameter_name": "user_group_description", + "description": "A short description of the User Group.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "handle", + "tool_parameter_name": "unique_mention_handle", + "description": "A mention handle. Must be unique among channels, users and User Groups.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "include_count", + "tool_parameter_name": "include_user_count", + "description": "Include the number of users in each User Group.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "team_id_for_user_group_creation", + "description": "Encoded team id where the user group has to be created, required if org token is used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "enable_section", + "tool_parameter_name": "enable_display_as_sidebar_section", + "description": "Configure this user group to show as a sidebar section for all group members. Note: Only relevant if group has 1 or more default channels added.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/usergroups.create" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/CustomUnfurlSlackUrls.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/CustomUnfurlSlackUrls.json new file mode 100644 index 00000000..1633b90c --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/CustomUnfurlSlackUrls.json @@ -0,0 +1,365 @@ +{ + "name": "CustomUnfurlSlackUrls", + "fully_qualified_name": "SlackApi.CustomUnfurlSlackUrls@0.1.0", + "description": "Provide custom unfurl behavior for user-posted URLs on Slack.\n\nThis tool should be called to customize how URLs posted by users are displayed in Slack by providing a custom unfurl behavior.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "channel_id", + "required": true, + "description": "ID of the Slack channel where the message is posted. Required with 'ts' for custom unfurl or with 'unfurl_id' and 'source'.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "message_timestamp", + "required": true, + "description": "Timestamp of the message to which unfurl behavior will be added. Ensure it corresponds to a message in the specified channel containing a fully-qualified URL registered with your Slack app.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "ts" + }, + { + "name": "unfurl_url_map", + "required": true, + "description": "A URL-encoded JSON map with URLs as keys and their corresponding unfurl data as values. Each URL should point to a single attachment, like message buttons.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "unfurls" + }, + { + "name": "authentication_invitation_message", + "required": false, + "description": "A simple formatted string sent as an ephemeral message inviting the user to authenticate for full unfurl behavior. Supports Slack's *bold*, _italics_, and linking formatting. If provided, this takes precedence over `authentication_invitation_url`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "user_auth_message" + }, + { + "name": "custom_authentication_url", + "required": false, + "description": "A URL to redirect users for app authentication to enable full URL unfurling, requires URL encoding.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "user_auth_url" + }, + { + "name": "user_authentication_blocks", + "required": false, + "description": "A URL-encoded JSON array of structured blocks to send as an ephemeral message for user authentication invitation.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "user_auth_blocks" + }, + { + "name": "unfurl_link_id", + "required": false, + "description": "The ID of the link to unfurl. Must be used with 'source'.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "unfurl_id" + }, + { + "name": "link_source", + "required": false, + "description": "Specify the source of the link to unfurl as either 'composer' for links inside the message composer or 'conversations_history' for links posted to a conversation. Must be used with 'unfurl_id', or alternatively with 'channel' and 'ts'.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "source" + }, + { + "name": "require_user_authentication", + "required": false, + "description": "Set to true if the user must install your Slack app to trigger unfurls for this domain.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "user_auth_required" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'chat.unfurl'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "links:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/chat.unfurl", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "channel_id", + "description": "Channel ID of the message. Both `channel` and `ts` must be provided together, or `unfurl_id` and `source` must be provided together.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "ts", + "tool_parameter_name": "message_timestamp", + "description": "Timestamp of the message to add unfurl behavior to.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "unfurls", + "tool_parameter_name": "unfurl_url_map", + "description": "URL-encoded JSON map with keys set to URLs featured in the message, pointing to their unfurl blocks or message attachments.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "user_auth_message", + "tool_parameter_name": "authentication_invitation_message", + "description": "Provide a simply-formatted string to send as an ephemeral message to the user as invitation to authenticate further and enable full unfurling behavior. Provides two buttons, `Not now` or `Never ask me again`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "user_auth_required", + "tool_parameter_name": "require_user_authentication", + "description": "Set to `true` or `1` to indicate the user must install your Slack app to trigger unfurls for this domain.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "user_auth_url", + "tool_parameter_name": "custom_authentication_url", + "description": "Send users to this custom URL where they will complete authentication in your app to fully trigger unfurling. Value should be properly URL-encoded.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "user_auth_blocks", + "tool_parameter_name": "user_authentication_blocks", + "description": "Provide a JSON based array of structured blocks presented as URL-encoded string to send as an ephemeral message to the user as invitation to authenticate further and enable full unfurling behavior", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "unfurl_id", + "tool_parameter_name": "unfurl_link_id", + "description": "The ID of the link to unfurl. Both `unfurl_id` and `source` must be provided together, or `channel` and `ts` must be provided together.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "source", + "tool_parameter_name": "link_source", + "description": "The source of the link to unfurl. The source may either be `composer`, when the link is inside the message composer, or `conversations_history`, when the link has been posted to a conversation.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/chat.unfurl" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/DeleteScheduledSlackMessage.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/DeleteScheduledSlackMessage.json new file mode 100644 index 00000000..20ad23da --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/DeleteScheduledSlackMessage.json @@ -0,0 +1,173 @@ +{ + "name": "DeleteScheduledSlackMessage", + "fully_qualified_name": "SlackApi.DeleteScheduledSlackMessage@0.1.0", + "description": "Delete a pending scheduled message from Slack queue.\n\nUse this tool to remove a scheduled message from the Slack queue. It requires \"chat:write\" OAuth scope, allowing you to manage messages as an authenticated user or bot.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "channel_id", + "required": true, + "description": "The ID of the channel where the scheduled message is set to post. Required to identify the correct message to delete.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "scheduled_message_id", + "required": true, + "description": "The ID of the scheduled message to be deleted. This ID is obtained from the `chat.scheduleMessage` response.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "scheduled_message_id" + }, + { + "name": "delete_as_authenticated_user", + "required": false, + "description": "Set to true to delete the message as the authenticated user with `chat:write:user` scope. Bot users are considered authenticated users. If false, the message will be deleted with `chat:write:bot` scope.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "as_user" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'chat.deleteScheduledMessage'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "chat:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/chat.deleteScheduledMessage", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "channel_id", + "description": "The channel the scheduled_message is posting to", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "scheduled_message_id", + "tool_parameter_name": "scheduled_message_id", + "description": "`scheduled_message_id` returned from call to chat.scheduleMessage", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "as_user", + "tool_parameter_name": "delete_as_authenticated_user", + "description": "Pass true to delete the message as the authed user with `chat:write:user` scope. Bot users in this context are considered authed users. If unused or false, the message will be deleted with `chat:write:bot` scope.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/chat.deletescheduledmessage" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/DenySharedInviteRequest.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/DenySharedInviteRequest.json new file mode 100644 index 00000000..b0f6b031 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/DenySharedInviteRequest.json @@ -0,0 +1,141 @@ +{ + "name": "DenySharedInviteRequest", + "fully_qualified_name": "SlackApi.DenySharedInviteRequest@0.1.0", + "description": "Denies an external user invitation to a Slack channel.\n\nUse this tool to deny a request that invites an external user to join a Slack channel. It should be called when such an invite needs to be rejected.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "shared_channel_invite_id", + "required": true, + "description": "The ID for the shared channel invite request that you intend to deny. This is required for specifying which invite to decline.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "invite_id" + }, + { + "name": "deny_invite_message", + "required": false, + "description": "An optional message explaining why the invitation was denied. This message will be sent to the requester.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "message" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'conversations.requestSharedInvite.deny'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "conversations.connect:manage" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/conversations.requestSharedInvite.deny", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "invite_id", + "tool_parameter_name": "shared_channel_invite_id", + "description": "ID of the requested shared channel invite to deny.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "message", + "tool_parameter_name": "deny_invite_message", + "description": "Optional message explaining why the request to invite was denied.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/conversations.requestsharedinvite.deny" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/DisableUserGroup.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/DisableUserGroup.json new file mode 100644 index 00000000..348e04a8 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/DisableUserGroup.json @@ -0,0 +1,173 @@ +{ + "name": "DisableUserGroup", + "fully_qualified_name": "SlackApi.DisableUserGroup@0.1.0", + "description": "Disable an existing Slack User Group.\n\nThis tool should be called to disable an existing User Group in Slack. It requires appropriate OAuth scopes and sends a POST request to the Slack API. Use this tool when you need to deactivate a User Group to prevent users from being able to reference or use it.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "user_group_id", + "required": true, + "description": "The encoded ID of the User Group to be disabled.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "usergroup" + }, + { + "name": "team_id", + "required": false, + "description": "Encoded target team ID where the user group exists. Required only if using an org-level token; ignored for workspace-level tokens.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "include_user_count", + "required": false, + "description": "Include the number of users in the User Group. Set to true to include the count.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_count" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'usergroups.disable'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "usergroups:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/usergroups.disable", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "usergroup", + "tool_parameter_name": "user_group_id", + "description": "The encoded ID of the User Group to disable.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "include_count", + "tool_parameter_name": "include_user_count", + "description": "Include the number of users in the User Group.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "team_id", + "description": "Encoded target team id where the user group is, required if org token is used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/usergroups.disable" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/EditSlackBookmark.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/EditSlackBookmark.json new file mode 100644 index 00000000..8a925207 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/EditSlackBookmark.json @@ -0,0 +1,237 @@ +{ + "name": "EditSlackBookmark", + "fully_qualified_name": "SlackApi.EditSlackBookmark@0.1.0", + "description": "Edit an existing bookmark in a Slack channel.\n\nThis tool is used to edit an existing bookmark in a specified Slack channel. It requires appropriate permissions and should be called when you need to update the details of a bookmark in any channel you have access to.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "slack_channel_id", + "required": true, + "description": "The ID of the Slack channel where the bookmark will be updated.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel_id" + }, + { + "name": "target_bookmark_id", + "required": true, + "description": "The unique identifier of the bookmark you want to update.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "bookmark_id" + }, + { + "name": "bookmark_title", + "required": false, + "description": "The new title for the bookmark to update.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "title" + }, + { + "name": "bookmark_link", + "required": false, + "description": "URL of the bookmark to be edited. Ensure it is a valid format starting with http or https.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "link" + }, + { + "name": "emoji_tag", + "required": false, + "description": "The emoji tag to apply to the bookmark link. It should be a valid emoji code (e.g., :smile:).", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "emoji" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'bookmarks.edit'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "bookmarks:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/bookmarks.edit", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel_id", + "tool_parameter_name": "slack_channel_id", + "description": "Channel to update bookmark in.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "bookmark_id", + "tool_parameter_name": "target_bookmark_id", + "description": "Bookmark to update.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "title", + "tool_parameter_name": "bookmark_title", + "description": "Title for the bookmark.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "link", + "tool_parameter_name": "bookmark_link", + "description": "Link to bookmark.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "emoji", + "tool_parameter_name": "emoji_tag", + "description": "Emoji tag to apply to the link.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/bookmarks.edit" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/EnableSlackFileSharing.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/EnableSlackFileSharing.json new file mode 100644 index 00000000..f7eed54b --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/EnableSlackFileSharing.json @@ -0,0 +1,109 @@ +{ + "name": "EnableSlackFileSharing", + "fully_qualified_name": "SlackApi.EnableSlackFileSharing@0.1.0", + "description": "Enable a Slack file for public sharing.\n\nThis tool enables a file for public or external sharing on Slack using the Slack API. It should be called when a user wants to share a file publicly outside their Slack workspace.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "file_id_to_share", + "required": true, + "description": "The ID of the file on Slack that you want to enable for public sharing.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "file" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'files.sharedPublicURL'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "files:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/files.sharedPublicURL", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "file", + "tool_parameter_name": "file_id_to_share", + "description": "File to share", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/files.sharedpublicurl" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/EnableSlackUserGroup.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/EnableSlackUserGroup.json new file mode 100644 index 00000000..9dc95303 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/EnableSlackUserGroup.json @@ -0,0 +1,173 @@ +{ + "name": "EnableSlackUserGroup", + "fully_qualified_name": "SlackApi.EnableSlackUserGroup@0.1.0", + "description": "Enable a user group in Slack.\n\nThis tool activates a specified user group in Slack. It should be called when an action is needed to enable a user group so that it can be used within Slack for communication or organizational purposes. This tool is particularly useful for managing Slack user groups efficiently.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "user_group_id", + "required": true, + "description": "The encoded ID of the User Group to be enabled in Slack.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "usergroup" + }, + { + "name": "team_id", + "required": false, + "description": "Provide the encoded team ID where the user group is located. Only required if using an org-level token. Ignored with workspace-level tokens.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "include_user_count", + "required": false, + "description": "Set to true to include the number of users in the User Group.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_count" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'usergroups.enable'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "usergroups:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/usergroups.enable", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "usergroup", + "tool_parameter_name": "user_group_id", + "description": "The encoded ID of the User Group to enable.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "include_count", + "tool_parameter_name": "include_user_count", + "description": "Include the number of users in the User Group.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "team_id", + "description": "Encoded team id where the user group is, required if org token is used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/usergroups.enable" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/FetchWorkspaceSettingsInfo.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/FetchWorkspaceSettingsInfo.json new file mode 100644 index 00000000..a0fbcced --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/FetchWorkspaceSettingsInfo.json @@ -0,0 +1,109 @@ +{ + "name": "FetchWorkspaceSettingsInfo", + "fully_qualified_name": "SlackApi.FetchWorkspaceSettingsInfo@0.1.0", + "description": "Retrieve settings information for a Slack workspace.\n\nThis tool calls the Slack API to fetch detailed information about settings in a specific workspace. It is useful for administrators who need to manage team settings. The tool requires appropriate OAuth scopes for access.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "slack_team_id", + "required": true, + "description": "The unique identifier of the Slack workspace (team) for which to fetch the settings information.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'admin.teams.settings.info'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "admin.teams:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/admin.teams.settings.info", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "team_id", + "tool_parameter_name": "slack_team_id", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/admin.teams.settings.info" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/FindSlackUserByEmail.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/FindSlackUserByEmail.json new file mode 100644 index 00000000..50613f48 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/FindSlackUserByEmail.json @@ -0,0 +1,109 @@ +{ + "name": "FindSlackUserByEmail", + "fully_qualified_name": "SlackApi.FindSlackUserByEmail@0.1.0", + "description": "Find a Slack user using their email address.\n\nThis tool allows you to search for a Slack user by their email address. It should be called when you need to retrieve user information based on email within Slack.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "user_email_address", + "required": true, + "description": "The email address of the user in the Slack workspace to search for.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "email" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'users.lookupByEmail'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "users:read.email" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/users.lookupByEmail", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "email", + "tool_parameter_name": "user_email_address", + "description": "An email address belonging to a user in the workspace", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/users.lookupbyemail" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetCallInformation.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetCallInformation.json new file mode 100644 index 00000000..3c57ac2b --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetCallInformation.json @@ -0,0 +1,109 @@ +{ + "name": "GetCallInformation", + "fully_qualified_name": "SlackApi.GetCallInformation@0.1.0", + "description": "Retrieve detailed information about a specific call in Slack.\n\nUse this tool to access detailed information about a call within Slack by providing the call ID. Useful for obtaining call metadata such as participants, start time, and more.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "call_id", + "required": true, + "description": "The unique identifier of the call as returned by the `calls.add` method. This ID is necessary to retrieve detailed call information.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'calls.info'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "calls:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/calls.info", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "id", + "tool_parameter_name": "call_id", + "description": "`id` of the Call returned by the `calls.add` method.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/calls.info" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetConversationInfo.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetConversationInfo.json new file mode 100644 index 00000000..50d6e900 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetConversationInfo.json @@ -0,0 +1,176 @@ +{ + "name": "GetConversationInfo", + "fully_qualified_name": "SlackApi.GetConversationInfo@0.1.0", + "description": "Fetches information about a Slack conversation.\n\nThis tool retrieves details about a specific conversation in Slack, such as its name, members, and other relevant data. It should be used when information about a Slack conversation is needed, and requires appropriate read permissions.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "conversation_id", + "required": true, + "description": "The unique ID of the Slack conversation to retrieve information for.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "include_locale", + "required": false, + "description": "Set to `true` to receive the locale for this conversation. Defaults to `false`.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_locale" + }, + { + "name": "include_member_count", + "required": false, + "description": "Set to true to include the member count for the specified conversation. Defaults to false.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_num_members" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'conversations.info'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "channels:read", + "groups:read", + "im:read", + "mpim:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/conversations.info", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "conversation_id", + "description": "Conversation ID to learn more about", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "include_locale", + "tool_parameter_name": "include_locale", + "description": "Set this to `true` to receive the locale for this conversation. Defaults to `false`.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "include_num_members", + "tool_parameter_name": "include_member_count", + "description": "Set to `true` to include the member count for the specified conversation. Defaults to `false`.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/conversations.info" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetCurrentSlackTeamInfo.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetCurrentSlackTeamInfo.json new file mode 100644 index 00000000..1b3b749f --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetCurrentSlackTeamInfo.json @@ -0,0 +1,141 @@ +{ + "name": "GetCurrentSlackTeamInfo", + "fully_qualified_name": "SlackApi.GetCurrentSlackTeamInfo@0.1.0", + "description": "Retrieve information about the current Slack team.\n\nThis tool is used to get information about the current Slack team, including settings and general details. It is called when there's a need to access team information in a Slack workspace.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "query_by_domain", + "required": false, + "description": "Comma-separated domains to query instead of a team, used when the team is not specified. This only works for domains in the same enterprise as the querying team token.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "domain" + }, + { + "name": "specific_team_id", + "required": false, + "description": "The ID of the Slack team to retrieve information about. If omitted, information about the current team will be returned.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'team.info'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "team:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/team.info", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "domain", + "tool_parameter_name": "query_by_domain", + "description": "Query by domain instead of team (only when team is null). This only works for domains in the same enterprise as the querying team token. This also expects the domain to belong to a team and not the enterprise itself. This is the value set up for the 'Joining This Workspace' workspace setting. If it contains more than one domain, the field will contain multiple comma-separated domain values. If no domain is set, the field is empty.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team", + "tool_parameter_name": "specific_team_id", + "description": "Team to get info about; if omitted, will return information about the current team.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/team.info" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetExternalFileUploadUrl.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetExternalFileUploadUrl.json new file mode 100644 index 00000000..9eb62d91 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetExternalFileUploadUrl.json @@ -0,0 +1,205 @@ +{ + "name": "GetExternalFileUploadUrl", + "fully_qualified_name": "SlackApi.GetExternalFileUploadUrl@0.1.0", + "description": "Retrieve a URL to upload an external file to Slack.\n\nThis tool is used to obtain a URL for uploading files externally to Slack, requiring the 'files:write' OAuth scope.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "file_size_in_bytes", + "required": true, + "description": "Specify the size of the file to be uploaded, measured in bytes. Ensure this value accurately reflects the file size.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "length" + }, + { + "name": "file_name", + "required": true, + "description": "The name of the file to be uploaded to Slack.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "filename" + }, + { + "name": "snippet_syntax_type", + "required": false, + "description": "Specify the syntax highlighting type for the snippet being uploaded, such as 'javascript', 'python', etc.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "snippet_type" + }, + { + "name": "alt_text_description", + "required": false, + "description": "A description of the image for screen-readers, limited to 1000 characters.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "alt_txt" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'files.getUploadURLExternal'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "files:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/files.getUploadURLExternal", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "length", + "tool_parameter_name": "file_size_in_bytes", + "description": "Size in bytes of the file being uploaded.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "filename", + "tool_parameter_name": "file_name", + "description": "Name of the file being uploaded.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "snippet_type", + "tool_parameter_name": "snippet_syntax_type", + "description": "Syntax type of the snippet being uploaded.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "alt_txt", + "tool_parameter_name": "alt_text_description", + "description": "Description of image for screen-reader.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/files.getuploadurlexternal" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetIntegrationLogs.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetIntegrationLogs.json new file mode 100644 index 00000000..f8d3f771 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetIntegrationLogs.json @@ -0,0 +1,301 @@ +{ + "name": "GetIntegrationLogs", + "fully_qualified_name": "SlackApi.GetIntegrationLogs@0.1.0", + "description": "Retrieve integration logs for the current Slack team.\n\nThis tool retrieves the integration logs for the current Slack team, providing insights into the team's integration history and activities. It requires admin OAuth scope to access the logs.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "filter_by_app_id", + "required": false, + "description": "Filter integration logs to a specific Slack app. If not provided, logs for all apps are retrieved.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "app_id" + }, + { + "name": "filter_by_change_type", + "required": false, + "description": "Specify the change type to filter logs. Options: 'added', 'removed', 'enabled', 'disabled', 'updated'. Defaults to all logs.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "change_type" + }, + { + "name": "result_count", + "required": false, + "description": "The number of log entries to retrieve. Specify the maximum number of logs to return in a single request. (default: '100')", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "count" + }, + { + "name": "result_page_number", + "required": false, + "description": "The specific page number of the integration logs to retrieve. Used for pagination. (default: '1')", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "page" + }, + { + "name": "filter_by_service_id", + "required": false, + "description": "Specify the service ID to filter integration logs related to a specific service. If not provided, logs for all services will be retrieved.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "service_id" + }, + { + "name": "encoded_team_id", + "required": false, + "description": "The encoded team ID to get logs from, required if using an org-level token. Ignored if using a workspace-level token.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "filter_by_user", + "required": false, + "description": "Filter logs generated by a specific user's actions. Defaults to all logs if not specified.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "user" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'team.integrationLogs'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "admin" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/team.integrationLogs", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "app_id", + "tool_parameter_name": "filter_by_app_id", + "description": "Filter logs to this Slack app. Defaults to all logs.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "change_type", + "tool_parameter_name": "filter_by_change_type", + "description": "Filter logs with this change type. Possible values are `added`, `removed`, `enabled`, `disabled`, and `updated`. Defaults to all logs.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "count", + "tool_parameter_name": "result_count", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "page", + "tool_parameter_name": "result_page_number", + "description": "The page number of the result set to retrieve.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "service_id", + "tool_parameter_name": "filter_by_service_id", + "description": "Filter logs to this service. Defaults to all logs.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "encoded_team_id", + "description": "Encoded team id to get logs from, required if org token is used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "user", + "tool_parameter_name": "filter_by_user", + "description": "Filter logs generated by this user\u2019s actions. Defaults to all logs.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/team.integrationlogs" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetRemoteFileInfoSlack.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetRemoteFileInfoSlack.json new file mode 100644 index 00000000..5250a44f --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetRemoteFileInfoSlack.json @@ -0,0 +1,141 @@ +{ + "name": "GetRemoteFileInfoSlack", + "fully_qualified_name": "SlackApi.GetRemoteFileInfoSlack@0.1.0", + "description": "Retrieve details about a remote file from Slack.\n\nUse this tool to get information about a remote file that has been added to Slack. It is useful when you need details regarding the file, such as its metadata or status within Slack.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "file_external_identifier", + "required": false, + "description": "The GUID defined by the creator for the remote file to retrieve its information.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "external_id" + }, + { + "name": "file_id", + "required": false, + "description": "The unique identifier of the file to retrieve information about. Use this to specify the file in Slack.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "file" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'files.remote.info'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "remote_files:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/files.remote.info", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "external_id", + "tool_parameter_name": "file_external_identifier", + "description": "Creator defined GUID for the file.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "file", + "tool_parameter_name": "file_id", + "description": "Specify a file by providing its ID.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/files.remote.info" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackBotInfo.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackBotInfo.json new file mode 100644 index 00000000..90f447de --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackBotInfo.json @@ -0,0 +1,141 @@ +{ + "name": "GetSlackBotInfo", + "fully_qualified_name": "SlackApi.GetSlackBotInfo@0.1.0", + "description": "Retrieve details about a Slack bot user.\n\nThis tool fetches information about a bot user in Slack. It should be called when details about a specific Slack bot are needed, such as its name, ID, or other metadata.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "target_bot_id", + "required": false, + "description": "The unique bot ID for which information is requested. This ID is specific to each workspace the bot is in.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "bot" + }, + { + "name": "team_id_for_org_token_use", + "required": false, + "description": "Encoded team or enterprise ID where the bot exists. Required if using an organization token. Ignored if using a workspace-level token.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'bots.info'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "users:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/bots.info", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "bot", + "tool_parameter_name": "target_bot_id", + "description": "Bot user to get info on", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "team_id_for_org_token_use", + "description": "Encoded team ID or enterprise ID where the bot exists, required if org token is used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/bots.info" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackConversationMembers.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackConversationMembers.json new file mode 100644 index 00000000..55f1801d --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackConversationMembers.json @@ -0,0 +1,176 @@ +{ + "name": "GetSlackConversationMembers", + "fully_qualified_name": "SlackApi.GetSlackConversationMembers@0.1.0", + "description": "Retrieve members from a specified Slack conversation.\n\nUse this tool to get a list of members in a specific Slack conversation. This can apply to public and private channels, as well as direct and multi-party direct message conversations. Appropriate OAuth scopes are required to access different types of conversations.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "conversation_id", + "required": true, + "description": "The ID of the Slack conversation to retrieve members from. This can be a channel, group, or direct message.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "pagination_cursor", + "required": false, + "description": "Cursor for pagination, set to the `next_cursor` value from a previous response to continue retrieving members from a conversation.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + }, + { + "name": "max_items_to_return", + "required": false, + "description": "The maximum number of conversation members to return. Recommended to specify a value under 1000, with no more than 200 results at a time for optimal pagination. (default: '100')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'conversations.members'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "channels:read", + "groups:read", + "im:read", + "mpim:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/conversations.members", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "conversation_id", + "description": "ID of the conversation to retrieve members for", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Paginate through collections of data by setting the `cursor` parameter to a `next_cursor` attribute returned by a previous request's `response_metadata`. Default value fetches the first \"page\" of the collection.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "max_items_to_return", + "description": "The maximum number of items to return. Fewer than the requested number of items may be returned, even if the end of the users list hasn't been reached.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/conversations.members" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackMessagePermalink.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackMessagePermalink.json new file mode 100644 index 00000000..dbd64bd3 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackMessagePermalink.json @@ -0,0 +1,139 @@ +{ + "name": "GetSlackMessagePermalink", + "fully_qualified_name": "SlackApi.GetSlackMessagePermalink@0.1.0", + "description": "Retrieve a permalink URL for a specific Slack message.\n\nThis tool retrieves a permalink URL for an existing message in Slack. Use it when you need the direct link to a particular message in a Slack channel.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "channel_id", + "required": true, + "description": "The unique identifier of the Slack conversation or channel containing the message.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "message_timestamp", + "required": true, + "description": "The unique timestamp of the message to retrieve the permalink for. It identifies the message within the Slack channel.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "message_ts" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'chat.getPermalink'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/chat.getPermalink", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "channel_id", + "description": "The ID of the conversation or channel containing the message", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "message_ts", + "tool_parameter_name": "message_timestamp", + "description": "A message's `ts` value, uniquely identifying it within a channel", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/chat.getpermalink" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackRemoteFilesInfo.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackRemoteFilesInfo.json new file mode 100644 index 00000000..ae025360 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackRemoteFilesInfo.json @@ -0,0 +1,237 @@ +{ + "name": "GetSlackRemoteFilesInfo", + "fully_qualified_name": "SlackApi.GetSlackRemoteFilesInfo@0.1.0", + "description": "Retrieve information about remote files added to Slack.\n\nThis tool fetches details about remote files stored in Slack. It is useful when you need to access metadata for files that have been added to Slack from external sources.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "filter_by_channel_id", + "required": false, + "description": "Filter remote files to only include those appearing in the specified Slack channel, indicated by its channel ID.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "pagination_cursor", + "required": false, + "description": "A cursor for paginating through data. Use the `next_cursor` from a prior request to fetch the next set of results. Defaults to the first page if not set.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + }, + { + "name": "maximum_items_to_return", + "required": false, + "description": "Specify the maximum number of remote file records to retrieve from Slack.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "filter_files_from_timestamp", + "required": false, + "description": "Filter files created after this inclusive timestamp. Use a Unix timestamp format. (default: '0')", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "ts_from" + }, + { + "name": "timestamp_filter_end", + "required": false, + "description": "Filter files created before this timestamp (inclusive) in Unix epoch time format. (default: 'now')", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "ts_to" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'files.remote.list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "remote_files:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/files.remote.list", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "filter_by_channel_id", + "description": "Filter files appearing in a specific channel, indicated by its ID.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Paginate through collections of data by setting the `cursor` parameter to a `next_cursor` attribute returned by a previous request's `response_metadata`. Default value fetches the first \"page\" of the collection.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "maximum_items_to_return", + "description": "The maximum number of items to return.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "ts_from", + "tool_parameter_name": "filter_files_from_timestamp", + "description": "Filter files created after this timestamp (inclusive).", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "ts_to", + "tool_parameter_name": "timestamp_filter_end", + "description": "Filter files created before this timestamp (inclusive).", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/files.remote.list" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackTeamPreferences.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackTeamPreferences.json new file mode 100644 index 00000000..0df53fcd --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackTeamPreferences.json @@ -0,0 +1,75 @@ +{ + "name": "GetSlackTeamPreferences", + "fully_qualified_name": "SlackApi.GetSlackTeamPreferences@0.1.0", + "description": "Retrieve a list of a workspace's team preferences.\n\nThis tool fetches team preferences from a Slack workspace. It should be called when there's a need to access or review team settings. Requires appropriate OAuth scope for access.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [] + }, + "output": { + "description": "Response from the API endpoint 'team.preferences.list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "team.preferences:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/team.preferences.list", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/team.preferences.list" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackThreadMessages.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackThreadMessages.json new file mode 100644 index 00000000..55674cae --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackThreadMessages.json @@ -0,0 +1,336 @@ +{ + "name": "GetSlackThreadMessages", + "fully_qualified_name": "SlackApi.GetSlackThreadMessages@0.1.0", + "description": "Retrieve messages from a Slack conversation thread.\n\nThis tool fetches a thread of messages posted to a specific conversation in Slack. It should be called when there is a need to review or analyze the message history of a public or private channel, a direct message, or a multi-party direct message. The tool requires appropriate OAuth scopes to access the message history.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "conversation_id", + "required": true, + "description": "The ID of the Slack conversation from which to fetch the message thread.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "thread_message_timestamp", + "required": true, + "description": "Unique identifier of a parent message or a thread message (timestamp). Fetches the thread or the single message.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "ts" + }, + { + "name": "pagination_cursor", + "required": false, + "description": "Cursor for pagination. Use the `next_cursor` from a previous response to fetch the next page of data.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + }, + { + "name": "latest_message_timestamp", + "required": false, + "description": "Only include messages posted before this Unix timestamp in the results. (default: 'now')", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "latest" + }, + { + "name": "maximum_items_to_return", + "required": false, + "description": "Specify the maximum number of messages to fetch. The default and maximum are 15 for certain apps, with possible rate limits. (default: '1000')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "start_time_unix_timestamp", + "required": false, + "description": "Only include messages after this Unix timestamp in results. (default: '0')", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "oldest" + }, + { + "name": "include_all_message_metadata", + "required": false, + "description": "Set to true to return all metadata associated with this message.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_all_metadata" + }, + { + "name": "include_boundary_timestamps", + "required": false, + "description": "Include messages with 'oldest' or 'latest' timestamps. Ignored unless either timestamp is specified.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "inclusive" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'conversations.replies'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "channels:history", + "groups:history", + "im:history", + "mpim:history" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/conversations.replies", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "conversation_id", + "description": "Conversation ID to fetch thread from.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "ts", + "tool_parameter_name": "thread_message_timestamp", + "description": "Unique identifier of either a thread\u2019s parent message or a message in the thread. `ts` must be the timestamp of an existing message with 0 or more replies. If there are no replies then just the single message referenced by `ts` will return - it is just an ordinary, unthreaded message.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Paginate through collections of data by setting the `cursor` parameter to a `next_cursor` attribute returned by a previous request's `response_metadata`. Default value fetches the first \"page\" of the collection.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "include_all_metadata", + "tool_parameter_name": "include_all_message_metadata", + "description": "Return all metadata associated with this message.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "inclusive", + "tool_parameter_name": "include_boundary_timestamps", + "description": "Include messages with `oldest` or `latest` timestamps in results. Ignored unless either timestamp is specified.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "latest", + "tool_parameter_name": "latest_message_timestamp", + "description": "Only messages before this Unix timestamp will be included in results.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "maximum_items_to_return", + "description": "The maximum number of items to return. Fewer than the requested number of items may be returned, even if the end of the users list hasn't been reached.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "oldest", + "tool_parameter_name": "start_time_unix_timestamp", + "description": "Only messages after this Unix timestamp will be included in results.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/conversations.replies" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackUserPresence.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackUserPresence.json new file mode 100644 index 00000000..5cd51452 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackUserPresence.json @@ -0,0 +1,109 @@ +{ + "name": "GetSlackUserPresence", + "fully_qualified_name": "SlackApi.GetSlackUserPresence@0.1.0", + "description": "Retrieve user presence information from Slack.\n\nUse this tool to get the presence status of a user on Slack, indicating whether they are active or away.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "target_user_id", + "required": false, + "description": "The Slack user ID for which you want to retrieve presence information. (default: 'authed user')", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "user" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'users.getPresence'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "users:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/users.getPresence", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "user", + "tool_parameter_name": "target_user_id", + "description": "User to get presence info on.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/users.getpresence" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackUserProfile.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackUserProfile.json new file mode 100644 index 00000000..fae44e99 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetSlackUserProfile.json @@ -0,0 +1,142 @@ +{ + "name": "GetSlackUserProfile", + "fully_qualified_name": "SlackApi.GetSlackUserProfile@0.1.0", + "description": "Retrieve Slack user profile information and custom status.\n\nThis tool fetches the profile information of a Slack user, including their custom status and email (if authorized). It requires appropriate read scopes (users.profile:read or users:read.email).", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "target_user_id", + "required": false, + "description": "The unique identifier of the Slack user whose profile information is to be retrieved.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "user" + }, + { + "name": "include_labels", + "required": false, + "description": "Include labels for each ID in custom profile fields. This option can heavily rate-limit requests and is not recommended. Default is false.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_labels" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'users.profile.get'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "users.profile:read", + "users:read.email" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/users.profile.get", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "include_labels", + "tool_parameter_name": "include_labels", + "description": "Include labels for each ID in custom profile fields. Using this parameter will heavily rate-limit your requests and is not recommended.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "user", + "tool_parameter_name": "target_user_id", + "description": "User to retrieve profile info for", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/users.profile.get" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetTeamBillableUsersInfo.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetTeamBillableUsersInfo.json new file mode 100644 index 00000000..84975ad6 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetTeamBillableUsersInfo.json @@ -0,0 +1,205 @@ +{ + "name": "GetTeamBillableUsersInfo", + "fully_qualified_name": "SlackApi.GetTeamBillableUsersInfo@0.1.0", + "description": "Retrieves billable users info for the current Slack team.\n\nUse this tool to obtain information about billable users in your Slack team. It requires administrative privileges with the 'admin' scope.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "pagination_cursor", + "required": false, + "description": "Cursor for pagination. Use the `next_cursor` from the previous response to fetch the next page of users. (default: 'fetches the first page')", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + }, + { + "name": "maximum_items_to_return", + "required": false, + "description": "Specifies the maximum number of billable user entries to be retrieved.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "specific_user_id", + "required": false, + "description": "The ID of a specific user to retrieve billable information for. Leave empty to retrieve info for all users.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "user" + }, + { + "name": "encoded_team_id", + "required": false, + "description": "Encoded team ID for retrieving billable info, required if using an org token. Ignored with workspace-level tokens.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'team.billableInfo'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "admin" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/team.billableInfo", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Set `cursor` to `next_cursor` returned by previous call, to indicate from where you want to list next page of users list.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "maximum_items_to_return", + "description": "The maximum number of items to return.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "user", + "tool_parameter_name": "specific_user_id", + "description": "A user to retrieve the billable information for. Defaults to all users.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "encoded_team_id", + "description": "Encoded team id to get the billable information from, required if org token is used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/team.billableinfo" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetTeamProfile.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetTeamProfile.json new file mode 100644 index 00000000..67936c5b --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetTeamProfile.json @@ -0,0 +1,109 @@ +{ + "name": "GetTeamProfile", + "fully_qualified_name": "SlackApi.GetTeamProfile@0.1.0", + "description": "Retrieve a team's profile information from Slack.\n\nThis tool retrieves a team's profile from Slack. It should be called when there's a need to access team information such as members, roles, or other relevant details. The tool uses the Slack API and requires the 'users.profile:read' OAuth scope.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "visibility_filter", + "required": false, + "description": "Filter the profile fields based on visibility. Options: 'all', 'visible', 'hidden'. Default is 'all'.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "visibility" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'team.profile.get'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "users.profile:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/team.profile.get", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "visibility", + "tool_parameter_name": "visibility_filter", + "description": "Filter by visibility.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/team.profile.get" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetUserIdentity.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetUserIdentity.json new file mode 100644 index 00000000..a24ae182 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/GetUserIdentity.json @@ -0,0 +1,76 @@ +{ + "name": "GetUserIdentity", + "fully_qualified_name": "SlackApi.GetUserIdentity@0.1.0", + "description": "Retrieve a user's identity information from Slack.\n\nThis tool is used to get detailed information about a user's identity on Slack. It should be called when user identity details are required, such as for authentication purposes or to display user information within an application leveraging Slack's API.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [] + }, + "output": { + "description": "Response from the API endpoint 'users.identity'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "identity.read", + "identity.basic" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/users.identity", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/users.identity" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/InviteUserToSlackChannel.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/InviteUserToSlackChannel.json new file mode 100644 index 00000000..44fba549 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/InviteUserToSlackChannel.json @@ -0,0 +1,173 @@ +{ + "name": "InviteUserToSlackChannel", + "fully_qualified_name": "SlackApi.InviteUserToSlackChannel@0.1.0", + "description": "Invite users to a Slack channel.\n\nThis tool sends an invitation to specified users to join a Slack channel. It should be called when you want to add new members to a channel via an invite.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "slack_channel_id", + "required": true, + "description": "The ID of the Slack channel to invite users to. It can be a public or private channel ID.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "user_ids_list", + "required": true, + "description": "A list of up to 100 user IDs to invite, separated by commas.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "users" + }, + { + "name": "continue_with_valid_users", + "required": false, + "description": "Set to true to invite valid users while ignoring invalid IDs when multiple user IDs are provided. Default is false.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "force" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'conversations.invite'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "conversations:write.invites" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/conversations.invite", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "slack_channel_id", + "description": "The ID of the public or private channel to invite user(s) to.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "users", + "tool_parameter_name": "user_ids_list", + "description": "A comma separated list of user IDs. Up to 100 users may be listed.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "force", + "tool_parameter_name": "continue_with_valid_users", + "description": "When set to `true` and multiple user IDs are provided, continue inviting the valid ones while disregarding invalid IDs.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/conversations.invite" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/JoinSlackConversation.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/JoinSlackConversation.json new file mode 100644 index 00000000..6d72acd7 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/JoinSlackConversation.json @@ -0,0 +1,110 @@ +{ + "name": "JoinSlackConversation", + "fully_qualified_name": "SlackApi.JoinSlackConversation@0.1.0", + "description": "Join an existing conversation in Slack.\n\nThis tool is used to join a specified conversation within Slack. It requires appropriate user permissions and should be called when there's a need to participate in an existing Slack channel.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "conversation_id", + "required": true, + "description": "The ID of the conversation or channel you want to join in Slack.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'conversations.join'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "channels:join", + "channels:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/conversations.join", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "conversation_id", + "description": "ID of conversation to join", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/conversations.join" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListAccessibleSlackConversations.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListAccessibleSlackConversations.json new file mode 100644 index 00000000..6b75e0a1 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListAccessibleSlackConversations.json @@ -0,0 +1,272 @@ +{ + "name": "ListAccessibleSlackConversations", + "fully_qualified_name": "SlackApi.ListAccessibleSlackConversations@0.1.0", + "description": "Retrieve a list of conversations the user can access on Slack.\n\nThis tool calls the Slack API to list all conversations (public channels, private channels, direct messages) that a user has access to. It can be used to view information about different types of conversations including public channels, private channels, and direct or group messages.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "pagination_cursor", + "required": false, + "description": "A cursor for pagination to continue listing conversations from a specific point. Use the 'next_cursor' from a previous response. Default is the first page.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + }, + { + "name": "maximum_items_to_return", + "required": false, + "description": "The maximum number of conversations to return in the response. Must be an integer with a maximum value of 999. It is recommended to request no more than 200 results at a time for optimal performance. (default: '100')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "slack_team_id", + "required": false, + "description": "The encoded ID of the Slack team to list conversations for. Required if using an organization-level token. Ignored if a workspace-level token is used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "channel_types", + "required": false, + "description": "Comma-separated list of channel types to filter conversations. Options: public_channel, private_channel, mpim, im. (default: 'public_channel')", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "types" + }, + { + "name": "specific_user_id", + "required": false, + "description": "Filter conversations by a specific user ID's membership. Only includes conversations shared with the calling user.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "user" + }, + { + "name": "exclude_archived_channels", + "required": false, + "description": "Set to true to exclude archived channels from the retrieved list of Slack conversations. (default: false)", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "exclude_archived" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'users.conversations'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "channels:read", + "groups:read", + "im:read", + "mpim:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/users.conversations", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Paginate through collections of data by setting the `cursor` parameter to a `next_cursor` attribute returned by a previous request's `response_metadata`. Default value fetches the first \"page\" of the collection. See pagination for more detail.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "exclude_archived", + "tool_parameter_name": "exclude_archived_channels", + "description": "Set to `true` to exclude archived channels from the list", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "maximum_items_to_return", + "description": "The maximum number of items to return. Fewer than the requested number of items may be returned, even if the end of the list hasn't been reached. Must be an integer with a max value of 999.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "slack_team_id", + "description": "Encoded team id to list conversations in, required if org token is used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "types", + "tool_parameter_name": "channel_types", + "description": "Mix and match channel types by providing a comma-separated list of any combination of `public_channel`, `private_channel`, `mpim`, `im`", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "user", + "tool_parameter_name": "specific_user_id", + "description": "Browse conversations by a specific user ID's membership. Non-public channels are restricted to those where the calling user shares membership.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/users.conversations" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListApprovedWorkspaceInviteRequests.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListApprovedWorkspaceInviteRequests.json new file mode 100644 index 00000000..dc1167f1 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListApprovedWorkspaceInviteRequests.json @@ -0,0 +1,173 @@ +{ + "name": "ListApprovedWorkspaceInviteRequests", + "fully_qualified_name": "SlackApi.ListApprovedWorkspaceInviteRequests@0.1.0", + "description": "Retrieve all approved workspace invite requests from Slack.\n\nThis tool retrieves a list of all approved invite requests for a Slack workspace. It should be called when there is a need to review or manage approved invitations. The response will include details of each invitation request.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "workspace_id", + "required": false, + "description": "ID for the Slack workspace where the invite requests were made. Required if the Enterprise org has more than one workspace.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "pagination_cursor", + "required": false, + "description": "Value of the `next_cursor` from the previous API response for paginating results.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + }, + { + "name": "result_limit", + "required": false, + "description": "Specify the number of results to return, between 1 and 1000 inclusive. (default: '100')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'admin.inviteRequests.approved.list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "admin.invites:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/admin.inviteRequests.approved.list", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "team_id", + "tool_parameter_name": "workspace_id", + "description": "ID for the workspace where the invite requests were made.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Value of the `next_cursor` field sent as part of the previous API response", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "result_limit", + "description": "The number of results that will be returned by the API on each invocation. Must be between 1 - 1000, both inclusive", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/admin.inviterequests.approved.list" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListChannelsForUsergroup.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListChannelsForUsergroup.json new file mode 100644 index 00000000..0c77a22b --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListChannelsForUsergroup.json @@ -0,0 +1,173 @@ +{ + "name": "ListChannelsForUsergroup", + "fully_qualified_name": "SlackApi.ListChannelsForUsergroup@0.1.0", + "description": "Retrieve channels linked to an org-level user group in Slack.\n\nFetches a list of channels associated with a specified organizational IDP group in Slack. This tool is useful for admins managing user groups and their related channels.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "usergroup_id", + "required": true, + "description": "The ID of the IDP group to list channels for. It identifies which organizational group to retrieve the default channels from.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "usergroup_id" + }, + { + "name": "workspace_id", + "required": false, + "description": "The unique identifier for the Slack workspace.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "include_member_count_in_channels", + "required": false, + "description": "Set to true to include the count of members for each channel, otherwise set to false.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_num_members" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'admin.usergroups.listChannels'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "admin.usergroups:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/admin.usergroups.listChannels", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "usergroup_id", + "tool_parameter_name": "usergroup_id", + "description": "ID of the IDP group to list default channels for.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "workspace_id", + "description": "ID of the the workspace.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "include_num_members", + "tool_parameter_name": "include_member_count_in_channels", + "description": "Flag to include or exclude the count of members per channel.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/admin.usergroups.listchannels" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListCustomEmojiForTeam.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListCustomEmojiForTeam.json new file mode 100644 index 00000000..c94d59bf --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListCustomEmojiForTeam.json @@ -0,0 +1,109 @@ +{ + "name": "ListCustomEmojiForTeam", + "fully_qualified_name": "SlackApi.ListCustomEmojiForTeam@0.1.0", + "description": "Retrieve a list of custom emojis for a specific team.\n\nUse this tool to get a list of custom emojis available for a team on Slack. It should be called when you need to display or manage team-specific emojis.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "include_emoji_categories", + "required": false, + "description": "Set to true to include categories for Unicode emojis in the response.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_categories" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'emoji.list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "emoji:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/emoji.list", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "include_categories", + "tool_parameter_name": "include_emoji_categories", + "description": "Include a list of categories for Unicode emoji and the emoji in each category", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/emoji.list" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListDeniedSlackInviteRequests.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListDeniedSlackInviteRequests.json new file mode 100644 index 00000000..e9739388 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListDeniedSlackInviteRequests.json @@ -0,0 +1,173 @@ +{ + "name": "ListDeniedSlackInviteRequests", + "fully_qualified_name": "SlackApi.ListDeniedSlackInviteRequests@0.1.0", + "description": "Retrieve denied Slack workspace invite requests.\n\nThis tool retrieves a list of all denied workspace invite requests on Slack. It should be called when there is a need to review or analyze denied invitations to a Slack workspace.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "workspace_team_id", + "required": false, + "description": "ID of the workspace where the invite requests were made. Required if the Enterprise org has multiple workspaces.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "pagination_cursor", + "required": false, + "description": "The cursor value from the previous API response to fetch the next set of results. Use this for pagination.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + }, + { + "name": "result_limit", + "required": false, + "description": "Specify the number of denied invite request results to return, between 1 and 1000 inclusive. (default: '100')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'admin.inviteRequests.denied.list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "admin.invites:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/admin.inviteRequests.denied.list", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "team_id", + "tool_parameter_name": "workspace_team_id", + "description": "ID for the workspace where the invite requests were made. Required if your Enterprise org contains more than one workspace.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Value of the `next_cursor` field sent as part of the previous API response.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "result_limit", + "description": "The number of results that will be returned by the API on each invocation. Must be between 1 - 1000 both inclusive", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/admin.inviterequests.denied.list" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListPendingWorkspaceInvites.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListPendingWorkspaceInvites.json new file mode 100644 index 00000000..ec536c12 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListPendingWorkspaceInvites.json @@ -0,0 +1,173 @@ +{ + "name": "ListPendingWorkspaceInvites", + "fully_qualified_name": "SlackApi.ListPendingWorkspaceInvites@0.1.0", + "description": "Retrieve all pending workspace invite requests from Slack.\n\nUse this tool to list all pending workspace invite requests in a Slack workspace. This can be useful for administrators managing team invitations. Requires 'admin.invites:read' OAuth scope.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "workspace_id", + "required": false, + "description": "The ID of the workspace to list pending invite requests from. Required for multi-workspace enterprises.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "pagination_cursor", + "required": false, + "description": "The cursor value for fetching the next set of invite requests. Use the `next_cursor` from the previous response if available.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + }, + { + "name": "result_limit", + "required": false, + "description": "The number of invite requests to return per call, must be between 1 and 1000. (default: '100')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'admin.inviteRequests.list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "admin.invites:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/admin.inviteRequests.list", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "team_id", + "tool_parameter_name": "workspace_id", + "description": "ID for the workspace where the invite requests were made. `team_id` is required if your Enterprise org contains more than one workspace.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Value of the `next_cursor` field sent as part of the previous API response", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "result_limit", + "description": "The number of results that will be returned by the API on each invocation. Must be between 1 - 1000, both inclusive.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/admin.inviterequests.list" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListPinnedItems.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListPinnedItems.json new file mode 100644 index 00000000..f75a2ce0 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListPinnedItems.json @@ -0,0 +1,109 @@ +{ + "name": "ListPinnedItems", + "fully_qualified_name": "SlackApi.ListPinnedItems@0.1.0", + "description": "Retrieve items pinned to a Slack channel.\n\nThis tool calls the Slack API to list all items pinned to a specific channel. It should be used when there is a need to display or manage pinned items in a Slack channel.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "channel_id", + "required": true, + "description": "The ID of the Slack channel to retrieve pinned items from. This is required to specify which channel's pinned items will be listed.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'pins.list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "pins:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/pins.list", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "channel_id", + "description": "Channel to get pinned items for.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/pins.list" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListScheduledMessages.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListScheduledMessages.json new file mode 100644 index 00000000..0de7d7ea --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListScheduledMessages.json @@ -0,0 +1,267 @@ +{ + "name": "ListScheduledMessages", + "fully_qualified_name": "SlackApi.ListScheduledMessages@0.1.0", + "description": "Retrieve scheduled messages from Slack.\n\nUse this tool to obtain a list of messages that are scheduled to be sent in a Slack workspace. It is useful for managing future communications and staying informed of pending messages.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "channel_id", + "required": false, + "description": "The ID of the Slack channel from which to retrieve scheduled messages.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "pagination_cursor", + "required": false, + "description": "Cursor value for pagination to specify the starting point of the list from a previous call.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + }, + { + "name": "latest_timestamp", + "required": false, + "description": "A Unix timestamp marking the latest point in the time range for fetching scheduled messages. Ensure it is greater than the `oldest` timestamp if both are set.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "latest" + }, + { + "name": "max_number_of_entries", + "required": false, + "description": "Specify the maximum number of scheduled messages to return from Slack.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "oldest_timestamp", + "required": false, + "description": "A Unix timestamp representing the start of the time range for scheduled messages. It must be less than the `latest_timestamp` if both are specified.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "oldest" + }, + { + "name": "team_id", + "required": false, + "description": "Encoded team ID to specify which team's channels to list. Required if using an org-level token; ignore for workspace-level tokens.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'chat.scheduledMessages.list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/chat.scheduledMessages.list", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "channel_id", + "description": "The channel of the scheduled messages.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "For pagination purposes, this is the `cursor` value returned from a previous call to `chat.scheduledmessages.list` indicating where you want to start this call from.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "latest", + "tool_parameter_name": "latest_timestamp", + "description": "A Unix timestamp of the latest value in the time range", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "max_number_of_entries", + "description": "Maximum number of original entries to return.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "oldest", + "tool_parameter_name": "oldest_timestamp", + "description": "A Unix timestamp of the oldest value in the time range.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "team_id", + "description": "Encoded team id to list channels in, required if org token is used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/chat.scheduledmessages.list" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSharedChannelInvites.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSharedChannelInvites.json new file mode 100644 index 00000000..540e6766 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSharedChannelInvites.json @@ -0,0 +1,173 @@ +{ + "name": "ListSharedChannelInvites", + "fully_qualified_name": "SlackApi.ListSharedChannelInvites@0.1.0", + "description": "Retrieve unapproved shared channel invites from Slack.\n\nThis tool retrieves a list of shared channel invites that have been generated or received but are not yet approved by all parties on Slack. It should be called when you need to manage or view pending shared channel invites.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "workspace_team_id", + "required": false, + "description": "The encoded team ID for the workspace to retrieve invites from. Required when using an organization token.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "maximum_invites_to_return", + "required": false, + "description": "Specify the maximum number of unapproved shared channel invites to retrieve. (default: '100')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "count" + }, + { + "name": "pagination_cursor", + "required": false, + "description": "The cursor for paginating through results, obtained from a previous call's next_cursor.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'conversations.listConnectInvites'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "conversations.connect:manage" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/conversations.listConnectInvites", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "team_id", + "tool_parameter_name": "workspace_team_id", + "description": "Encoded team id for the workspace to retrieve invites for, required if org token is used", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "count", + "tool_parameter_name": "maximum_invites_to_return", + "description": "Maximum number of invites to return", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Set to `next_cursor` returned by previous call to list items in subsequent page", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/conversations.listconnectinvites" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackChannels.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackChannels.json new file mode 100644 index 00000000..3d699de9 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackChannels.json @@ -0,0 +1,240 @@ +{ + "name": "ListSlackChannels", + "fully_qualified_name": "SlackApi.ListSlackChannels@0.1.0", + "description": "Retrieve a list of all channels in a Slack team.\n\nThis tool retrieves a list of all public and private channels that the user has access to within a Slack team. It can also view direct and multiparty direct messages, depending on the user's permissions.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "pagination_cursor", + "required": false, + "description": "The cursor used to paginate through data collections. Use the `next_cursor` from a previous response to continue; omit for the first page.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + }, + { + "name": "maximum_number_of_channels", + "required": false, + "description": "Specify the maximum number of channels to return. Must be an integer under 1000. Note that fewer channels than requested may be returned. (default: '100')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "team_id_for_org_app", + "required": false, + "description": "Encoded team ID to list channels. Required for org-level tokens; ignored for workspace-level tokens.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "channel_types", + "required": false, + "description": "Comma-separated list of channel types to include, e.g., 'public_channel', 'private_channel', 'mpim', 'im'. (default: 'public_channel')", + "value_schema": { + "val_type": "string", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "types" + }, + { + "name": "exclude_archived_channels", + "required": false, + "description": "Set to true to exclude archived channels from the list of Slack channels. Default is false.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "exclude_archived" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'conversations.list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "channels:read", + "groups:read", + "im:read", + "mpim:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/conversations.list", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Paginate through collections of data by setting the `cursor` parameter to a `next_cursor` attribute returned by a previous request's `response_metadata`. Default value fetches the first \"page\" of the collection.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "exclude_archived", + "tool_parameter_name": "exclude_archived_channels", + "description": "Set to `true` to exclude archived channels from the list.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "maximum_number_of_channels", + "description": "The maximum number of items to return. Fewer than the requested number of items may be returned, even if the end of the list hasn't been reached. Must be an integer under 1000.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "team_id_for_org_app", + "description": "Encoded team id to list channels in, required if token belongs to org-wide app.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "types", + "tool_parameter_name": "channel_types", + "description": "Mix and match channel types by providing a comma-separated list of any combination of `public_channel`, `private_channel`, `mpim`, `im`", + "value_schema": { + "val_type": "string", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/conversations.list" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackEnterpriseEmojis.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackEnterpriseEmojis.json new file mode 100644 index 00000000..f899bcad --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackEnterpriseEmojis.json @@ -0,0 +1,141 @@ +{ + "name": "ListSlackEnterpriseEmojis", + "fully_qualified_name": "SlackApi.ListSlackEnterpriseEmojis@0.1.0", + "description": "Retrieve emojis for a Slack Enterprise organization.\n\nThis tool uses the Slack Admin API to fetch a list of emojis available in a Slack Enterprise organization. It requires the appropriate OAuth scope to access team information.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "pagination_cursor", + "required": false, + "description": "Cursor for fetching the next page of emojis. Use 'next_cursor' from the previous response.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + }, + { + "name": "max_items_to_return", + "required": false, + "description": "The maximum number of emojis to return, between 1 and 1000 inclusive. (default: '100')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'admin.emoji.list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "admin.teams:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/admin.emoji.list", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "max_items_to_return", + "description": "The maximum number of items to return. Must be between 1 - 1000 both inclusive.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/admin.emoji.list" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackTeamUsers.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackTeamUsers.json new file mode 100644 index 00000000..c6880984 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackTeamUsers.json @@ -0,0 +1,206 @@ +{ + "name": "ListSlackTeamUsers", + "fully_qualified_name": "SlackApi.ListSlackTeamUsers@0.1.0", + "description": "Fetches a list of all users in a Slack team.\n\nThis tool retrieves a comprehensive list of all users within a specified Slack team. It includes user details and can access email information if the appropriate OAuth scopes are provided.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "pagination_cursor", + "required": false, + "description": "Cursor for paginating through data. Use the `next_cursor` from a previous response to continue.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + }, + { + "name": "maximum_items_to_return", + "required": false, + "description": "Maximum number of users to return (recommended max is 200 for pagination).", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "slack_team_id", + "required": false, + "description": "The encoded team ID to list users from, necessary if an organization-level token is used. Ignored if a workspace-level token is provided.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "include_user_locale", + "required": false, + "description": "Set to true to receive locale information for each user. Default is false.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_locale" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'users.list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "users:read", + "users:read.email" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/users.list", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Paginate through collections of data by setting the `cursor` parameter to a `next_cursor` attribute returned by a previous request's `response_metadata`. Default value fetches the first \"page\" of the collection. See [pagination](https://docs.slack.dev/apis/web-api/pagination) for more detail.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "include_locale", + "tool_parameter_name": "include_user_locale", + "description": "Set this to `true` to receive the locale for users.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "maximum_items_to_return", + "description": "The maximum number of items to return. Fewer than the requested number of items may be returned, even if the end of the users list hasn't been reached. Providing no `limit` value will result in Slack attempting to deliver you the entire result set. If the collection is too large you may experience `limit_required` or HTTP 500 errors.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "slack_team_id", + "description": "Encoded team ID to list users in, required if org token is used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/users.list" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackUserGroups.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackUserGroups.json new file mode 100644 index 00000000..931c700c --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackUserGroups.json @@ -0,0 +1,205 @@ +{ + "name": "ListSlackUserGroups", + "fully_qualified_name": "SlackApi.ListSlackUserGroups@0.1.0", + "description": "Retrieve all user groups for a Slack team.\n\nThis tool retrieves a list of all user groups available in a Slack team. It should be called when there's a need to access or display user group information within a Slack workspace.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "team_id_for_org_token", + "required": false, + "description": "Encoded team ID required when using an org-level token. Ignored if using a workspace-level token.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "include_user_count", + "required": false, + "description": "Set to true to include the number of users in each User Group.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_count" + }, + { + "name": "include_disabled_groups", + "required": false, + "description": "Set to true to include disabled user groups in the results.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_disabled" + }, + { + "name": "include_users_in_group", + "required": false, + "description": "Include the list of users for each User Group in the response.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_users" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'usergroups.list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "usergroups:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/usergroups.list", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "include_count", + "tool_parameter_name": "include_user_count", + "description": "Include the number of users in each User Group.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "include_disabled", + "tool_parameter_name": "include_disabled_groups", + "description": "Include results for disabled User Groups.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "include_users", + "tool_parameter_name": "include_users_in_group", + "description": "Include the list of users for each User Group.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "team_id_for_org_token", + "description": "The user group's encoded team ID. Required if org token is used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/usergroups.list" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackWorkspaceOwners.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackWorkspaceOwners.json new file mode 100644 index 00000000..95fc89a1 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListSlackWorkspaceOwners.json @@ -0,0 +1,173 @@ +{ + "name": "ListSlackWorkspaceOwners", + "fully_qualified_name": "SlackApi.ListSlackWorkspaceOwners@0.1.0", + "description": "Retrieve all owners in a Slack workspace.\n\nThis tool retrieves a list of all the owners in a specified Slack workspace, using the admin.teams.owners.list API endpoint. It is useful for managing or viewing the user roles within a Slack workspace.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "workspace_id", + "required": true, + "description": "The unique identifier of the Slack workspace for which to list the owners.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "maximum_items_to_return", + "required": false, + "description": "Specifies the maximum number of owners to return, ranging from 1 to 1000. (default: '100')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "pagination_cursor", + "required": false, + "description": "The cursor from the previous response used to fetch the next page of owners. Leave empty for the first page.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'admin.teams.owners.list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "admin.teams:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/admin.teams.owners.list", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "team_id", + "tool_parameter_name": "workspace_id", + "description": "The ID of the team (workspace) for which you want to list the owners.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "maximum_items_to_return", + "description": "The maximum number of items to return. Must be between 1 - 1000 both inclusive.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/admin.teams.owners.list" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListTeamsInEnterprise.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListTeamsInEnterprise.json new file mode 100644 index 00000000..b9970f2c --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListTeamsInEnterprise.json @@ -0,0 +1,141 @@ +{ + "name": "ListTeamsInEnterprise", + "fully_qualified_name": "SlackApi.ListTeamsInEnterprise@0.1.0", + "description": "Retrieve all teams in an Enterprise organization on Slack.\n\nThis tool retrieves a list of all teams within an Enterprise organization on Slack, utilizing the admin.teams.list endpoint. It should be called when information about the teams in an Enterprise organization is needed.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "maximum_items_to_return", + "required": false, + "description": "Specify the maximum number of teams to retrieve. Must be a positive integer, up to 1000. (default: '100')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "pagination_cursor", + "required": false, + "description": "Use this to retrieve the next page of results by setting it to the `next_cursor` from the previous response.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'admin.teams.list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "admin.teams:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/admin.teams.list", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "limit", + "tool_parameter_name": "maximum_items_to_return", + "description": "The maximum number of items to return. Must be a positive integer no larger than 1000.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/admin.teams.list" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListWorkspaceUsers.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListWorkspaceUsers.json new file mode 100644 index 00000000..fa2767ac --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ListWorkspaceUsers.json @@ -0,0 +1,269 @@ +{ + "name": "ListWorkspaceUsers", + "fully_qualified_name": "SlackApi.ListWorkspaceUsers@0.1.0", + "description": "Retrieve a list of users from a Slack workspace.\n\nUse this tool to get a list of users in a specific Slack workspace. It's helpful for administrators who need to manage or view user information within the workspace.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "workspace_team_id", + "required": false, + "description": "The ID of the Slack workspace (e.g., T1234) to filter users from. Only users from this workspace will be listed.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "pagination_cursor", + "required": false, + "description": "Use this to navigate through paginated results by setting it to the `next_cursor` from a previous response.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + }, + { + "name": "user_retrieval_limit", + "required": false, + "description": "Maximum number of users to retrieve per page from the Slack workspace. (default: '100')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "return_only_active_users", + "required": false, + "description": "Return only active users if true; return only deactivated users if false. Default is true.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "is_active" + }, + { + "name": "include_deactivated_user_workspaces", + "required": false, + "description": "Include workspaces for users even if they are deactivated. Only applies with org token and no team_id. Default is false.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_deactivated_user_workspaces" + }, + { + "name": "return_only_guest_users", + "required": false, + "description": "If true, returns only guests and their expiration dates that belong to the specified team_id.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "only_guests" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'admin.users.list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "admin.users:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/admin.users.list", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "team_id", + "tool_parameter_name": "workspace_team_id", + "description": "The ID (T1234) of a workspace. Filters results to just the specified workspace.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Set `cursor` to `next_cursor` returned by the previous call to list items in the next page.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "is_active", + "tool_parameter_name": "return_only_active_users", + "description": "If true, only active users will be returned. If false, only deactivated users will be returned. Default is true.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "include_deactivated_user_workspaces", + "tool_parameter_name": "include_deactivated_user_workspaces", + "description": "Only applies with org token and no team_id. If true, return `workspaces` for a user even if they may be deactivated on them. If false, return `workspaces` for a user only when user is active on them.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "only_guests", + "tool_parameter_name": "return_only_guest_users", + "description": "If true, returns only guests and their expiration dates that belong to the team_id.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "user_retrieval_limit", + "description": "Limit for how many users to be retrieved per page", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/admin.users.list" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/OpenOrResumeSlackConversation.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/OpenOrResumeSlackConversation.json new file mode 100644 index 00000000..13292f44 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/OpenOrResumeSlackConversation.json @@ -0,0 +1,209 @@ +{ + "name": "OpenOrResumeSlackConversation", + "fully_qualified_name": "SlackApi.OpenOrResumeSlackConversation@0.1.0", + "description": "Open or resume a direct or multi-person message in Slack.\n\nThis tool calls the Slack API to open a new conversation or resume an existing direct message or multi-person direct message. It should be used when there's a need to start or continue a conversation within Slack.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "conversation_channel_id", + "required": false, + "description": "The ID of an existing direct or multi-person message channel to resume. Alternatively, provide the `users` field to start a new conversation.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "target_user_ids", + "required": false, + "description": "A comma-separated list of user IDs to open or resume a conversation. Provide 1 to 8 IDs. Supplying 1 ID opens a 1:1 DM, while more than 1 ID opens a multi-person DM. Do not include the caller's ID.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "users" + }, + { + "name": "return_full_im_channel_definition", + "required": false, + "description": "Set to true to receive the entire IM channel definition; false returns only the conversation ID.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "return_im" + }, + { + "name": "prevent_creation", + "required": false, + "description": "If true, does not create a new conversation and instead checks for an existing DM or MPDM.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "prevent_creation" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'conversations.open'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "channels:manage", + "channels:write", + "groups:write", + "im:write", + "mpim:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/conversations.open", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "conversation_channel_id", + "description": "Resume a conversation by supplying an `im` or `mpim`'s ID. Or provide the `users` field instead.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "return_im", + "tool_parameter_name": "return_full_im_channel_definition", + "description": "Boolean, indicates you want the full IM channel definition in the response.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "users", + "tool_parameter_name": "target_user_ids", + "description": "Comma separated lists of users. If only one user is included, this creates a 1:1 DM. The ordering of the users is preserved whenever a multi-person direct message is returned. Supply a `channel` when not supplying `users`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "prevent_creation", + "tool_parameter_name": "prevent_creation", + "description": "Do not create a direct message or multi-person direct message. This is used to see if there is an existing dm or mpdm.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/conversations.open" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/PinItemToSlackChannel.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/PinItemToSlackChannel.json new file mode 100644 index 00000000..5c60e4ef --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/PinItemToSlackChannel.json @@ -0,0 +1,141 @@ +{ + "name": "PinItemToSlackChannel", + "fully_qualified_name": "SlackApi.PinItemToSlackChannel@0.1.0", + "description": "Pin an item to a Slack channel.\n\nUse this tool to pin an item to a specific channel in Slack, enhancing visibility for important content.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "channel_id", + "required": true, + "description": "The ID of the Slack channel where the message will be pinned. A `timestamp` must also be provided.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "message_timestamp", + "required": false, + "description": "The timestamp (`ts`) of the message to pin in the Slack channel. Ensure the channel is also specified.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "timestamp" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'pins.add'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "pins:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/pins.add", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "channel_id", + "description": "Channel to pin the message to. You must also include a `timestamp` when pinning messages.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "timestamp", + "tool_parameter_name": "message_timestamp", + "description": "Timestamp of the message to pin. You must also include the `channel`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/pins.add" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/RegisterSlackCall.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/RegisterSlackCall.json new file mode 100644 index 00000000..a21743c5 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/RegisterSlackCall.json @@ -0,0 +1,333 @@ +{ + "name": "RegisterSlackCall", + "fully_qualified_name": "SlackApi.RegisterSlackCall@0.1.0", + "description": "Registers a new call on Slack.\n\nThis tool registers a new call on Slack using the Slack API. It should be called when you want to create and log a new call event in a Slack workspace. The tool requires appropriate permissions (calls:write scope).", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "unique_call_id", + "required": true, + "description": "A unique ID for the Call, provided by the 3rd-party Call provider. Ensure it is unique across all calls from your service.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "external_unique_id" + }, + { + "name": "call_join_url", + "required": true, + "description": "The URL required for a client to join the Call on Slack.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "join_url" + }, + { + "name": "optional_human_readable_display_id", + "required": false, + "description": "An optional, human-readable ID for the call, supplied by the third-party provider. This ID will be displayed in the Call object if given.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "external_display_id" + }, + { + "name": "desktop_app_join_url", + "required": false, + "description": "The URL used to directly launch the 3rd-party Call from Slack clients, if provided.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "desktop_app_join_url" + }, + { + "name": "call_start_timestamp", + "required": false, + "description": "Unix timestamp indicating when the call is scheduled to start.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "date_start" + }, + { + "name": "call_title", + "required": false, + "description": "The name of the Call to be registered on Slack. This title will be used to identify the Call within Slack.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "title" + }, + { + "name": "call_creator_user_id", + "required": false, + "description": "The valid Slack user ID of the creator of this call. Optional if using a user token, which defaults to the authed user.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "created_by" + }, + { + "name": "participants_info", + "required": false, + "description": "A list of participants to register for the call, including 'slack_id', 'external_id', 'display_name', and 'avatar_url' for each user.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "users" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'calls.add'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "calls:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/calls.add", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "external_unique_id", + "tool_parameter_name": "unique_call_id", + "description": "An ID supplied by the 3rd-party Call provider. It must be unique across all Calls from that service.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "join_url", + "tool_parameter_name": "call_join_url", + "description": "The URL required for a client to join the Call.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "external_display_id", + "tool_parameter_name": "optional_human_readable_display_id", + "description": "An optional, human-readable ID supplied by the 3rd-party Call provider. If supplied, this ID will be displayed in the Call object.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "desktop_app_join_url", + "tool_parameter_name": "desktop_app_join_url", + "description": "When supplied, available Slack clients will attempt to directly launch the 3rd-party Call with this URL.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "date_start", + "tool_parameter_name": "call_start_timestamp", + "description": "Unix timestamp of the call start time", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "title", + "tool_parameter_name": "call_title", + "description": "The name of the Call.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "created_by", + "tool_parameter_name": "call_creator_user_id", + "description": "The valid Slack user ID of the user who created this Call. Required unless the method is called with a user token, in which case it defaults to the authed user of the token.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "users", + "tool_parameter_name": "participants_info", + "description": "The list of users to register as participants in the Call.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/calls.add" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/RemoveCallParticipants.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/RemoveCallParticipants.json new file mode 100644 index 00000000..7c6a117d --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/RemoveCallParticipants.json @@ -0,0 +1,141 @@ +{ + "name": "RemoveCallParticipants", + "fully_qualified_name": "SlackApi.RemoveCallParticipants@0.1.0", + "description": "Remove participants from a Slack call.\n\nThis tool removes specified participants from a call in Slack by registering their removal. Useful when a user needs to manage call attendees.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "call_id", + "required": true, + "description": "The unique identifier for the call from which participants are to be removed. This `id` is obtained from the `calls.add` method.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "id" + }, + { + "name": "users_to_remove", + "required": true, + "description": "A list of user IDs to remove as participants from the call. Refer to Slack's documentation for specifying user IDs.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "users" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'calls.participants.remove'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "calls:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/calls.participants.remove", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "id", + "tool_parameter_name": "call_id", + "description": "`id` returned by the `calls.add` method.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "users", + "tool_parameter_name": "users_to_remove", + "description": "The list of users to remove as participants in the Call.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/calls.participants.remove" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/RemoveReactionFromItem.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/RemoveReactionFromItem.json new file mode 100644 index 00000000..3ea263dd --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/RemoveReactionFromItem.json @@ -0,0 +1,237 @@ +{ + "name": "RemoveReactionFromItem", + "fully_qualified_name": "SlackApi.RemoveReactionFromItem@0.1.0", + "description": "Remove a reaction from a Slack item.\n\nUse this tool to remove a reaction (emoji) from a message, file, or file comment in Slack. This tool is intended for situations where a reaction needs to be revoked. It requires the 'reactions:write' scope, which allows the app to manage reactions on behalf of the user.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "reaction_emoji_name", + "required": true, + "description": "The name of the emoji reaction to be removed, such as 'smile' or 'thumbsup'.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "name" + }, + { + "name": "target_file_id", + "required": false, + "description": "The identifier of the file from which to remove the reaction. Specify either this, `target_file_comment_id`, or both `target_channel_id` and `target_message_timestamp`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "file" + }, + { + "name": "file_comment_id", + "required": false, + "description": "The ID of the file comment from which you want to remove the reaction. Provide this if the reaction is on a file comment.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "file_comment" + }, + { + "name": "message_channel_id", + "required": false, + "description": "Channel ID where the message to remove the reaction from was posted. Required if removing a reaction from a message. Use in combination with 'message_timestamp'.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "message_timestamp", + "required": false, + "description": "The exact timestamp of the message from which to remove the reaction. Specify when targeting a message.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "timestamp" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'reactions.remove'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "reactions:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/reactions.remove", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "name", + "tool_parameter_name": "reaction_emoji_name", + "description": "Reaction (emoji) name.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "file", + "tool_parameter_name": "target_file_id", + "description": "File to remove reaction from.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "file_comment", + "tool_parameter_name": "file_comment_id", + "description": "File comment to remove reaction from.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "channel", + "tool_parameter_name": "message_channel_id", + "description": "Channel where the message to remove reaction from was posted.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "timestamp", + "tool_parameter_name": "message_timestamp", + "description": "Timestamp of the message to remove reaction from.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/reactions.remove" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/RemoveSlackBookmark.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/RemoveSlackBookmark.json new file mode 100644 index 00000000..e60ab9ad --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/RemoveSlackBookmark.json @@ -0,0 +1,173 @@ +{ + "name": "RemoveSlackBookmark", + "fully_qualified_name": "SlackApi.RemoveSlackBookmark@0.1.0", + "description": "Remove a bookmark from a Slack channel.\n\nThis tool removes a specified bookmark from a Slack channel. It should be called when a user wants to delete a bookmark that is no longer needed or relevant. Requires appropriate permissions to execute.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "slack_channel_id_to_remove_bookmark", + "required": true, + "description": "The ID of the Slack channel from which the bookmark should be removed. This ID specifies the target channel and is required to locate and delete the bookmark.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel_id" + }, + { + "name": "bookmark_id_to_remove", + "required": true, + "description": "The ID of the bookmark to be removed from a Slack channel. Ensure it is specified correctly to delete the correct bookmark.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "bookmark_id" + }, + { + "name": "quip_section_id", + "required": false, + "description": "The ID of the Quip section to unbookmark. This is required to specify which section's bookmark should be removed.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "quip_section_id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'bookmarks.remove'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "bookmarks:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/bookmarks.remove", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel_id", + "tool_parameter_name": "slack_channel_id_to_remove_bookmark", + "description": "Channel to remove bookmark.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "bookmark_id", + "tool_parameter_name": "bookmark_id_to_remove", + "description": "Bookmark to remove.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "quip_section_id", + "tool_parameter_name": "quip_section_id", + "description": "Quip section ID to unbookmark", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/bookmarks.remove" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/RenameSlackEmoji.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/RenameSlackEmoji.json new file mode 100644 index 00000000..08120167 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/RenameSlackEmoji.json @@ -0,0 +1,141 @@ +{ + "name": "RenameSlackEmoji", + "fully_qualified_name": "SlackApi.RenameSlackEmoji@0.1.0", + "description": "Rename an emoji in a Slack Enterprise organization.\n\nUse this tool to rename a custom emoji within a Slack Enterprise organization. It requires appropriate OAuth scope for team operations.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "current_emoji_name", + "required": true, + "description": "The current name of the emoji to be renamed. Colons (:myemoji:) around the value are optional.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "name" + }, + { + "name": "new_emoji_name", + "required": true, + "description": "The new name to assign to the emoji in the Slack Enterprise organization.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "new_name" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'admin.emoji.rename'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "admin.teams:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/admin.emoji.rename", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "name", + "tool_parameter_name": "current_emoji_name", + "description": "The name of the emoji to be renamed. Colons (:myemoji:) around the value are not required, although they may be included.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "new_name", + "tool_parameter_name": "new_emoji_name", + "description": "The new name of the emoji.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/admin.emoji.rename" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/RevokeSlackToken.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/RevokeSlackToken.json new file mode 100644 index 00000000..48992429 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/RevokeSlackToken.json @@ -0,0 +1,107 @@ +{ + "name": "RevokeSlackToken", + "fully_qualified_name": "SlackApi.RevokeSlackToken@0.1.0", + "description": "Revoke a Slack authentication token.\n\nThis tool is used to revoke a Slack authentication token via a GET request to the Slack API endpoint. It should be called when it is necessary to invalidate a token to ensure it is no longer usable.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "trigger_testing_mode", + "required": false, + "description": "Set to true to trigger testing mode where the token will not be revoked. Useful for testing.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "test" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'auth.revoke'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/auth.revoke", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "test", + "tool_parameter_name": "trigger_testing_mode", + "description": "Setting this parameter to `1` triggers a testing mode where the specified token will not actually be revoked.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/auth.revoke" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ScheduleSlackMessage.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ScheduleSlackMessage.json new file mode 100644 index 00000000..98a28b33 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ScheduleSlackMessage.json @@ -0,0 +1,493 @@ +{ + "name": "ScheduleSlackMessage", + "fully_qualified_name": "SlackApi.ScheduleSlackMessage@0.1.0", + "description": "Schedule a message to be sent later in Slack.\n\nThis tool schedules a message to be sent to a specific Slack channel at a designated future time. It utilizes the Slack API endpoint 'chat.scheduleMessage' and requires the 'chat:write' OAuth scope.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "slack_channel_id_or_name", + "required": true, + "description": "Specify the target Slack channel, private group, or DM. Use an encoded ID or the channel name. Retrieve channel ID via `conversations.list`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "schedule_time_unix_timestamp", + "required": true, + "description": "Unix timestamp for when the message should be posted to Slack. Must be within 120 days and not exceed 30 messages per 5-minute window.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "post_at" + }, + { + "name": "attachments_json", + "required": false, + "description": "A JSON array of structured attachments as a URL-encoded string for the Slack message.", + "value_schema": { + "val_type": "string", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "attachments" + }, + { + "name": "structured_blocks_json", + "required": false, + "description": "A URL-encoded string of a JSON-based array containing structured blocks for message formatting.", + "value_schema": { + "val_type": "string", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "blocks" + }, + { + "name": "message_markdown", + "required": false, + "description": "Message text in markdown format. Avoid using with 'blocks' or 'text'. Maximum 12,000 characters.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "markdown_text" + }, + { + "name": "message_parsing_mode", + "required": false, + "description": "Specifies how the message content should be parsed and interpreted when sending to Slack. For more details, refer to chat.postMessage documentation.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "parse" + }, + { + "name": "message_text", + "required": false, + "description": "The main body of the Slack message or a fallback text when using blocks. Can be plain text or formatted with mrkdwn.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "text" + }, + { + "name": "parent_message_timestamp", + "required": false, + "description": "Timestamp of the parent message to which this message is a reply. Use the original message's timestamp, not a reply's timestamp.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "thread_ts" + }, + { + "name": "metadata_json", + "required": false, + "description": "JSON object containing 'event_type' and 'event_payload' fields. Must be URL-encoded. Note: using this will prevent scheduled messages from posting.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "metadata" + }, + { + "name": "enable_group_linking", + "required": false, + "description": "Set to true to link user groups in the message. Linking individual users is not supported; use mention syntax instead.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "link_names" + }, + { + "name": "make_reply_visible_to_everyone", + "required": false, + "description": "Set to true to make the reply visible to everyone in the channel or conversation. Use with `thread_ts`. Defaults to false.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "reply_broadcast" + }, + { + "name": "enable_link_unfurling", + "required": false, + "description": "Pass true to enable unfurling of primarily text-based content.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "unfurl_links" + }, + { + "name": "disable_unfurling_of_media_content", + "required": false, + "description": "Set to true to disable unfurling of media content. Defaults to false.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "unfurl_media" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'chat.scheduleMessage'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "chat:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/chat.scheduleMessage", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "slack_channel_id_or_name", + "description": "Channel, private group, or DM channel to send message to. Can be an encoded ID, or a name.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "post_at", + "tool_parameter_name": "schedule_time_unix_timestamp", + "description": "Unix timestamp representing the future time the message should post to Slack.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "attachments", + "tool_parameter_name": "attachments_json", + "description": "A JSON-based array of structured attachments, presented as a URL-encoded string.", + "value_schema": { + "val_type": "string", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "blocks", + "tool_parameter_name": "structured_blocks_json", + "description": "A JSON-based array of structured blocks, presented as a URL-encoded string.", + "value_schema": { + "val_type": "string", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "link_names", + "tool_parameter_name": "enable_group_linking", + "description": "Find and link user groups. No longer supports linking individual users; use syntax shown in Mentioning Users instead.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "markdown_text", + "tool_parameter_name": "message_markdown", + "description": "Accepts message text formatted in markdown. This argument should not be used in conjunction with `blocks` or `text`. Limit this field to 12,000 characters.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "parse", + "tool_parameter_name": "message_parsing_mode", + "description": "Change how messages are treated. See chat.postMessage for more details.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "reply_broadcast", + "tool_parameter_name": "make_reply_visible_to_everyone", + "description": "Indicates whether reply should be made visible to everyone in the channel or conversation. Used in conjunction with `thread_ts`.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "text", + "tool_parameter_name": "message_text", + "description": "How this field works and whether it is required depends on other fields you use in your API call. If using blocks, this is used as a fallback string to display in notifications. If not using blocks, this is the main body text of the message. It can be formatted as plain text or with `mrkdwn`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "thread_ts", + "tool_parameter_name": "parent_message_timestamp", + "description": "Provide another message's `ts` value to make this message a reply. Avoid using a reply's `ts` value; use its parent instead.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "unfurl_links", + "tool_parameter_name": "enable_link_unfurling", + "description": "Pass true to enable unfurling of primarily text-based content.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "unfurl_media", + "tool_parameter_name": "disable_unfurling_of_media_content", + "description": "Pass false to disable unfurling of media content.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "metadata", + "tool_parameter_name": "metadata_json", + "description": "JSON object with event_type and event_payload fields, presented as a URL-encoded string. Metadata you post to Slack is accessible to any app or user who is a member of that workspace.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/chat.schedulemessage" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/SearchFilesInSlack.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SearchFilesInSlack.json new file mode 100644 index 00000000..ad445008 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SearchFilesInSlack.json @@ -0,0 +1,301 @@ +{ + "name": "SearchFilesInSlack", + "fully_qualified_name": "SlackApi.SearchFilesInSlack@0.1.0", + "description": "Search for files in Slack using a query.\n\nThis tool searches for files in Slack that match a given query. It is useful when a user needs to locate specific files shared in Slack channels or direct messages. The tool returns a list of files that meet the search criteria.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "search_query", + "required": true, + "description": "The text string to search for in Slack files. Use keywords or phrases to narrow down results.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "query" + }, + { + "name": "items_per_page", + "required": false, + "description": "The number of file results to return per page. Maximum allowed value is 100. (default: '20')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "count" + }, + { + "name": "results_page_number", + "required": false, + "description": "The specific page number of results to retrieve, with a maximum value of 100. (default: '1')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "page" + }, + { + "name": "sort_files_by", + "required": false, + "description": "Specify how to sort the search results: either by 'score' or 'timestamp'. (default: 'score')", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "sort" + }, + { + "name": "sort_direction", + "required": false, + "description": "Change the sort direction for search results to ascending ('asc') or descending ('desc'). (default: 'desc')", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "sort_dir" + }, + { + "name": "encoded_team_id", + "required": false, + "description": "Encoded team ID to specify the search domain when using an org-level token. Ignored with a workspace-level token.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "enable_query_highlight", + "required": false, + "description": "Set to true to enable highlight markers for matching query terms in the search results.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "highlight" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'search.files'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "search:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/search.files", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "query", + "tool_parameter_name": "search_query", + "description": "Search query.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "count", + "tool_parameter_name": "items_per_page", + "description": "", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "highlight", + "tool_parameter_name": "enable_query_highlight", + "description": "Pass a value of `true` to enable query highlight markers.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "page", + "tool_parameter_name": "results_page_number", + "description": "", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "sort", + "tool_parameter_name": "sort_files_by", + "description": "Return matches sorted by either `score` or `timestamp`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "sort_dir", + "tool_parameter_name": "sort_direction", + "description": "Change sort direction to ascending ( `asc`) or descending ( `desc`).", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "encoded_team_id", + "description": "Encoded team id to search in, required if org token is used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/search.files" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/SearchSlackMessages.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SearchSlackMessages.json new file mode 100644 index 00000000..fa2abcf2 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SearchSlackMessages.json @@ -0,0 +1,333 @@ +{ + "name": "SearchSlackMessages", + "fully_qualified_name": "SlackApi.SearchSlackMessages@0.1.0", + "description": "Search Slack messages based on a query.\n\nThis tool searches for messages in a Slack workspace that match a specified query. It should be called when users want to find specific messages or discussions within their Slack channels.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "search_query", + "required": true, + "description": "The text to search for in Slack messages. Use keywords or phrases to narrow down results.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "query" + }, + { + "name": "results_per_page", + "required": false, + "description": "The number of search results to return per page, with a maximum limit of 100. (default: '20')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "count" + }, + { + "name": "page_number", + "required": false, + "description": "The page number of search results to retrieve, maximum value of 100. (default: '1')", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "page" + }, + { + "name": "pagination_cursor", + "required": false, + "description": "Use '*' for the first call to start pagination or provide the 'next_cursor' value from previous results to continue.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "cursor" + }, + { + "name": "sort_results_by", + "required": false, + "description": "Specify the criterion for sorting the search results, either by 'score' for relevance or 'timestamp' for chronological order. (default: 'score')", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "sort" + }, + { + "name": "sort_direction", + "required": false, + "description": "Specify the order for sorting results: use 'asc' for ascending or 'desc' for descending. (default: 'desc')", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "sort_dir" + }, + { + "name": "team_id", + "required": false, + "description": "The encoded team ID to search within. Required only if an organization-level token is used. Ignored for workspace-level tokens.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "enable_query_highlighting", + "required": false, + "description": "Set to true to enable query highlight markers, marking matching terms in the results.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "highlight" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'search.messages'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "search:read" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/search.messages", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "query", + "tool_parameter_name": "search_query", + "description": "Search query.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "count", + "tool_parameter_name": "results_per_page", + "description": "Pass the number of results you want per \"page\". Maximum of `100`.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "highlight", + "tool_parameter_name": "enable_query_highlighting", + "description": "Pass a value of `true` to enable query highlight markers.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "page", + "tool_parameter_name": "page_number", + "description": "", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "cursor", + "tool_parameter_name": "pagination_cursor", + "description": "Use this when getting results with cursormark pagination. For first call send `*` for subsequent calls, send the value of `next_cursor` returned in the previous call's results.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "sort", + "tool_parameter_name": "sort_results_by", + "description": "Return matches sorted by either `score` or `timestamp`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "sort_dir", + "tool_parameter_name": "sort_direction", + "description": "Change sort direction to ascending (`asc`) or descending (`desc`).", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "team_id", + "description": "Encoded team id to search in, required if org token is used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/search.messages" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/SendEphemeralMessageSlack.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SendEphemeralMessageSlack.json new file mode 100644 index 00000000..49c3d6f0 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SendEphemeralMessageSlack.json @@ -0,0 +1,461 @@ +{ + "name": "SendEphemeralMessageSlack", + "fully_qualified_name": "SlackApi.SendEphemeralMessageSlack@0.1.0", + "description": "Send an ephemeral message to a user in a Slack channel.\n\nThis tool sends an ephemeral message to a user within a specified Slack channel. It's useful for sending temporary messages or notifications that only the specified user can see. Requires the 'chat:write' scope.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "target_channel", + "required": true, + "description": "The channel, private group, or IM channel where the ephemeral message will be sent. Accepts an encoded ID or the channel's name.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "recipient_user_id", + "required": true, + "description": "The ID of the user who will receive the ephemeral message. Must be in the specified channel.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "user" + }, + { + "name": "structured_attachments", + "required": false, + "description": "A JSON-encoded array of structured attachments for the message. Presented as a URL-encoded string.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "attachments" + }, + { + "name": "structured_blocks", + "required": false, + "description": "A URL-encoded JSON array of structured Slack block elements. Use for rich message formatting.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "blocks" + }, + { + "name": "message_icon_emoji", + "required": false, + "description": "Emoji to display as the message icon, overriding icon_url. Specify using the emoji name like :smile:.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "icon_emoji" + }, + { + "name": "message_icon_url", + "required": false, + "description": "URL for the image to be used as the icon for the message. It overrides the icon_emoji if provided.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "icon_url" + }, + { + "name": "message_markdown_text", + "required": false, + "description": "The main text formatted in markdown to be sent as an ephemeral message. Do not use with `blocks` or `text`. Character limit: 12,000.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "markdown_text" + }, + { + "name": "message_parse_mode", + "required": false, + "description": "Specifies how the message text is interpreted. Options are: 'none', 'full', 'mrkdwn', or 'false'. Defaults to 'none'. (default: 'none')", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "parse" + }, + { + "name": "ephemeral_message_text", + "required": false, + "description": "The main text of the ephemeral message for Slack. It acts as a fallback when using blocks; can be formatted as plain text or markdown. Limit to a few thousand bytes.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "text" + }, + { + "name": "parent_message_timestamp", + "required": false, + "description": "The timestamp of the parent message to post this ephemeral message in its thread. Ensure there is already an active thread.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "thread_ts" + }, + { + "name": "bot_username", + "required": false, + "description": "The username for the bot sending the ephemeral message. This sets the display name in the Slack message.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "username" + }, + { + "name": "link_names_auto_link", + "required": false, + "description": "Set to true to automatically find and link channel names and usernames.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "link_names" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'chat.postEphemeral'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "chat:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/chat.postEphemeral", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "target_channel", + "description": "Channel, private group, or IM channel to send message to. Can be an encoded ID, or a name.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "user", + "tool_parameter_name": "recipient_user_id", + "description": "ID of the user who will receive the ephemeral message. The user should be in the channel specified by the `channel` argument.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "attachments", + "tool_parameter_name": "structured_attachments", + "description": "A JSON-based array of structured attachments, presented as a URL-encoded string.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "blocks", + "tool_parameter_name": "structured_blocks", + "description": "A JSON-based array of structured blocks, presented as a URL-encoded string.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "icon_emoji", + "tool_parameter_name": "message_icon_emoji", + "description": "Emoji to use as the icon for this message. Overrides `icon_url`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "icon_url", + "tool_parameter_name": "message_icon_url", + "description": "URL to an image to use as the icon for this message.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "link_names", + "tool_parameter_name": "link_names_auto_link", + "description": "Find and link channel names and usernames.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "markdown_text", + "tool_parameter_name": "message_markdown_text", + "description": "Accepts message text formatted in markdown. This argument should not be used in conjunction with `blocks` or `text`. Limit this field to 12,000 characters.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "parse", + "tool_parameter_name": "message_parse_mode", + "description": "Change how messages are treated. Defaults to `none`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "text", + "tool_parameter_name": "ephemeral_message_text", + "description": "How this field works and whether it is required depends on other fields you use in your API call. If you're using `blocks`, this is used as a fallback string to display in notifications. If you aren't, this is the main body text of the message. It can be formatted as plain text, or with `mrkdwn`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "thread_ts", + "tool_parameter_name": "parent_message_timestamp", + "description": "Provide another message's `ts` value to post this message in a thread. Avoid using a reply's `ts` value; use its parent's value instead. Ephemeral messages in threads are only shown if there is already an active thread.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "username", + "tool_parameter_name": "bot_username", + "description": "Set your bot's user name.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/chat.postephemeral" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/SendSlackMessage.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SendSlackMessage.json new file mode 100644 index 00000000..4f0ab251 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SendSlackMessage.json @@ -0,0 +1,619 @@ +{ + "name": "SendSlackMessage", + "fully_qualified_name": "SlackApi.SendSlackMessage@0.1.0", + "description": "Sends a message to a Slack channel.\n\nThis tool allows you to send messages to a Slack channel or direct message on behalf of an authenticated user. It is useful for automating communications within Slack workspaces.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "target_channel_id_or_name", + "required": true, + "description": "The encoded ID or name of the channel, private group, or IM where the message will be sent. Retrieve using Slack's conversations.list API.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "message_attachments", + "required": false, + "description": "A JSON array of structured attachment objects for the message, provided as a URL-encoded string. Example: `[{\"pretext\": \"pre-hello\", \"text\": \"text-world\"}]`.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "attachments" + }, + { + "name": "structured_blocks", + "required": false, + "description": "A JSON-based array of structured blocks for constructing messages using Block Kit. Provide as a URL-encoded string. Include fallback text if necessary.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "blocks" + }, + { + "name": "emoji_icon_for_message", + "required": false, + "description": "Emoji to display as the icon for the Slack message. Overrides any image URL icon.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "icon_emoji" + }, + { + "name": "message_icon_url", + "required": false, + "description": "URL to an image to use as the icon for the message. Overrides any specified icon emoji.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "icon_url" + }, + { + "name": "message_markdown", + "required": false, + "description": "The message text formatted using markdown, up to 12,000 characters. Cannot be used with `blocks` or `text`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "markdown_text" + }, + { + "name": "message_metadata", + "required": false, + "description": "A JSON object with 'event_type' and 'event_payload' fields, URL-encoded, providing additional metadata for the message.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "metadata" + }, + { + "name": "parse_mode", + "required": false, + "description": "Specifies how the message content should be treated. Options are 'none' to remove hyperlinks or 'full' to ignore markdown formatting.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "parse" + }, + { + "name": "message_text", + "required": false, + "description": "The main text of the message. Acts as the primary message or a fallback for notifications when using blocks. Supports plain text or markdown.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "text" + }, + { + "name": "thread_timestamp", + "required": false, + "description": "Timestamp of the parent message to which this message will be a reply. Use the parent's `ts` value, not a reply's.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "thread_ts" + }, + { + "name": "bot_username", + "required": false, + "description": "The display name to use for the bot when sending the message to Slack.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "username" + }, + { + "name": "post_as_authenticated_user", + "required": false, + "description": "Set to true to post the message as the authenticated user instead of as a bot. Only applicable for classic apps.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "as_user" + }, + { + "name": "link_user_groups", + "required": false, + "description": "Enable linking of user groups in the message. Individual user linking is not supported.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "link_names" + }, + { + "name": "enable_slack_markup_parsing", + "required": false, + "description": "Set to true to enable Slack markup parsing in the message. Default is enabled.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "mrkdwn" + }, + { + "name": "broadcast_reply_to_channel", + "required": false, + "description": "Set to true to make the reply visible to everyone in the channel when responding to a thread. Use with 'thread_ts'. Default is false.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "reply_broadcast" + }, + { + "name": "enable_unfurling_text_content", + "required": false, + "description": "Set to true to enable unfurling of primarily text-based content in Slack messages.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "unfurl_links" + }, + { + "name": "disable_media_unfurling", + "required": false, + "description": "Set to false to enable media unfurling and true to disable it. (default: 'false')", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "unfurl_media" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'chat.postMessage'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "chat:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/chat.postMessage", + "http_method": "POST", + "headers": {}, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "target_channel_id_or_name", + "description": "An encoded ID or channel name that represents a channel, private group, or IM channel to send the message to.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "as_user", + "tool_parameter_name": "post_as_authenticated_user", + "description": "(Legacy) Pass true to post the message as the authed user instead of as a bot. Can only be used by classic apps.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "attachments", + "tool_parameter_name": "message_attachments", + "description": "A JSON-based array of structured attachments, presented as a URL-encoded string.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "blocks", + "tool_parameter_name": "structured_blocks", + "description": "A JSON-based array of structured blocks, presented as a URL-encoded string.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "icon_emoji", + "tool_parameter_name": "emoji_icon_for_message", + "description": "Emoji to use as the icon for this message. Overrides `icon_url`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "icon_url", + "tool_parameter_name": "message_icon_url", + "description": "URL to an image to use as the icon for this message.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "link_names", + "tool_parameter_name": "link_user_groups", + "description": "Find and link user groups. No longer supports linking individual users; use syntax shown in Mentioning Users instead.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "markdown_text", + "tool_parameter_name": "message_markdown", + "description": "Accepts message text formatted in markdown. This argument should not be used in conjunction with `blocks` or `text`. Limit this field to 12,000 characters.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "metadata", + "tool_parameter_name": "message_metadata", + "description": "JSON object with event_type and event_payload fields, presented as a URL-encoded string. Metadata you post to Slack is accessible to any app or user who is a member of that workspace.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "mrkdwn", + "tool_parameter_name": "enable_slack_markup_parsing", + "description": "Disable Slack markup parsing by setting to `false`. Enabled by default.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "parse", + "tool_parameter_name": "parse_mode", + "description": "Change how messages are treated. By default, URLs will be hyperlinked. Set `parse` to `none` to remove the hyperlinks. The behavior of `parse` is different for text formatted with `mrkdwn`. By default, or when `parse` is set to `none`, `mrkdwn` formatting is implemented. To ignore `mrkdwn` formatting, set `parse` to `full`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "reply_broadcast", + "tool_parameter_name": "broadcast_reply_to_channel", + "description": "Used in conjunction with `thread_ts` and indicates whether reply should be made visible to everyone in the channel or conversation.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "text", + "tool_parameter_name": "message_text", + "description": "The main body text of the message. The usage of the `text` field changes depending on whether you're using `blocks`. If you're using `blocks`, this is used as a fallback string to display in notifications. If you aren't, this is the main body text of the message. It can be formatted as plain text or with `mrkdwn`. It's recommended for providing a fallback when using `blocks`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "thread_ts", + "tool_parameter_name": "thread_timestamp", + "description": "Provide another message's `ts` value to make this message a reply. Avoid using a reply's `ts` value; use its parent instead.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "unfurl_links", + "tool_parameter_name": "enable_unfurling_text_content", + "description": "Pass true to enable unfurling of primarily text-based content.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "unfurl_media", + "tool_parameter_name": "disable_media_unfurling", + "description": "Pass false to disable unfurling of media content.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "username", + "tool_parameter_name": "bot_username", + "description": "Set your bot's user name.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/chat.postmessage" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/SetSlackChannelReadCursor.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SetSlackChannelReadCursor.json new file mode 100644 index 00000000..10bd6700 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SetSlackChannelReadCursor.json @@ -0,0 +1,145 @@ +{ + "name": "SetSlackChannelReadCursor", + "fully_qualified_name": "SlackApi.SetSlackChannelReadCursor@0.1.0", + "description": "Update the read cursor in a Slack channel.\n\nUse this tool to mark a specific point in a Slack channel as read. This is useful for keeping track of the latest read messages in channels, groups, or direct messages. Requires appropriate Slack OAuth scopes.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "channel_id", + "required": true, + "description": "The ID of the Slack channel or conversation where you want to set the read cursor. This should be a valid Slack channel ID.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channel" + }, + { + "name": "timestamp_of_message_to_mark_as_read", + "required": true, + "description": "The unique identifier (timestamp) of the message you want to mark as most recently seen in the conversation.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "ts" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'conversations.mark'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "channels:manage", + "channels:write", + "groups:write", + "im:write", + "mpim:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/conversations.mark", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channel", + "tool_parameter_name": "channel_id", + "description": "Channel or conversation to set the read cursor for.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "ts", + "tool_parameter_name": "timestamp_of_message_to_mark_as_read", + "description": "Unique identifier of message you want marked as most recently seen in this conversation.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/conversations.mark" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/SetSlackProfilePhoto.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SetSlackProfilePhoto.json new file mode 100644 index 00000000..53cd0d64 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SetSlackProfilePhoto.json @@ -0,0 +1,205 @@ +{ + "name": "SetSlackProfilePhoto", + "fully_qualified_name": "SlackApi.SetSlackProfilePhoto@0.1.0", + "description": "Set the user's profile photo on Slack.\n\nUse this tool to update a user's profile photo on Slack. This requires the 'users.profile:write' OAuth scope, allowing changes to profile information including the profile photo.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "crop_box_size", + "required": false, + "description": "The size of the square crop box for the profile photo in pixels. Specify the width and height, which are the same value for a square.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "crop_w" + }, + { + "name": "crop_box_x_coordinate", + "required": false, + "description": "X coordinate of the top-left corner of the crop box for the profile photo.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "crop_x" + }, + { + "name": "crop_y_coordinate", + "required": false, + "description": "Y coordinate of the top-left corner of the crop box for the user's profile photo on Slack. This determines where the cropping of the image will start on the vertical axis.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "crop_y" + }, + { + "name": "profile_photo_image", + "required": false, + "description": "The image file to set as the Slack profile photo. Provide image data directly with the correct content type (e.g., image/jpeg, image/png).", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "image" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'users.setPhoto'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "users.profile:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/users.setPhoto", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "crop_w", + "tool_parameter_name": "crop_box_size", + "description": "Width/height of crop box (always square)", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "crop_x", + "tool_parameter_name": "crop_box_x_coordinate", + "description": "X coordinate of top-left corner of crop box", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "crop_y", + "tool_parameter_name": "crop_y_coordinate", + "description": "Y coordinate of top-left corner of crop box", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "image", + "tool_parameter_name": "profile_photo_image", + "description": "File contents via `multipart/form-data`.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/users.setphoto" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/SetSlackWorkspaceName.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SetSlackWorkspaceName.json new file mode 100644 index 00000000..1e8e3573 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SetSlackWorkspaceName.json @@ -0,0 +1,141 @@ +{ + "name": "SetSlackWorkspaceName", + "fully_qualified_name": "SlackApi.SetSlackWorkspaceName@0.1.0", + "description": "Update the name of a Slack workspace.\n\nUse this tool to update the name of a specified Slack workspace. This tool should be called when there's a need to change the workspace name. It requires appropriate permissions.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "workspace_id", + "required": true, + "description": "Unique identifier for the Slack workspace whose name you want to update.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "new_workspace_name", + "required": true, + "description": "The desired new name for the Slack workspace. This replaces the existing name.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "name" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'admin.teams.settings.setName'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "admin.teams:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/admin.teams.settings.setName", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "team_id", + "tool_parameter_name": "workspace_id", + "description": "ID for the workspace to set the name for.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "name", + "tool_parameter_name": "new_workspace_name", + "description": "The new name of the workspace.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/admin.teams.settings.setname" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/SetWorkspaceDescription.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SetWorkspaceDescription.json new file mode 100644 index 00000000..470cbc15 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/SetWorkspaceDescription.json @@ -0,0 +1,141 @@ +{ + "name": "SetWorkspaceDescription", + "fully_qualified_name": "SlackApi.SetWorkspaceDescription@0.1.0", + "description": "Update the description of a Slack workspace.\n\nThis tool updates the description of a specified workspace in Slack. It requires admin permissions with the 'admin.teams:write' scope. It should be called when there is a need to change or set a new description for a Slack team.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "workspace_id", + "required": true, + "description": "The unique identifier for the Slack workspace where the description will be updated.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "workspace_description", + "required": true, + "description": "The new description to set for the Slack workspace. Provide a clear and concise text.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "description" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'admin.teams.settings.setDescription'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "admin.teams:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/admin.teams.settings.setDescription", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "team_id", + "tool_parameter_name": "workspace_id", + "description": "ID for the workspace to set the description for.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "description", + "tool_parameter_name": "workspace_description", + "description": "The new description for the workspace.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/admin.teams.settings.setdescription" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/ShareRemoteFileInChannel.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ShareRemoteFileInChannel.json new file mode 100644 index 00000000..30071d8e --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/ShareRemoteFileInChannel.json @@ -0,0 +1,173 @@ +{ + "name": "ShareRemoteFileInChannel", + "fully_qualified_name": "SlackApi.ShareRemoteFileInChannel@0.1.0", + "description": "Share a remote file into a Slack channel.\n\nThis tool shares a specified remote file into a selected Slack channel. It utilizes Slack's API to facilitate file sharing across channels.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "target_channel_ids", + "required": true, + "description": "Comma-separated list of Slack channel IDs where the remote file will be shared. Ensure IDs are valid and the user has permission to share files in these channels.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channels" + }, + { + "name": "file_external_identifier", + "required": false, + "description": "The globally unique identifier (GUID) for the file set by the app when registering with Slack. Required if 'file' is not provided.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "external_id" + }, + { + "name": "file_id", + "required": false, + "description": "The ID of a file registered with Slack to be shared. Required if `external_id` is not provided.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "file" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'files.remote.share'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "remote_files:share" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/files.remote.share", + "http_method": "GET", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "channels", + "tool_parameter_name": "target_channel_ids", + "description": "Comma-separated list of channel IDs where the file will be shared.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "external_id", + "tool_parameter_name": "file_external_identifier", + "description": "The globally unique identifier (GUID) for the file, as set by the app registering the file with Slack. Either this field or `file` or both are required.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "file", + "tool_parameter_name": "file_id", + "description": "Specify a file registered with Slack by providing its ID. Either this field or `external_id` or both are required.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/files.remote.share" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/UpdateSlackUserGroup.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/UpdateSlackUserGroup.json new file mode 100644 index 00000000..1712b0eb --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/UpdateSlackUserGroup.json @@ -0,0 +1,365 @@ +{ + "name": "UpdateSlackUserGroup", + "fully_qualified_name": "SlackApi.UpdateSlackUserGroup@0.1.0", + "description": "Update an existing User Group in Slack.\n\nThis tool updates an existing User Group in Slack. It should be called when you need to modify the details of a user group, such as its name or permissions. Ensure the appropriate permissions are granted with the 'usergroups:write' scope.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "user_group_id", + "required": true, + "description": "The encoded ID of the User Group to update in Slack.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "usergroup" + }, + { + "name": "default_channel_ids", + "required": false, + "description": "A comma-separated list of channel IDs where the User Group is set as default. Use encoded channel IDs.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "channels" + }, + { + "name": "additional_channel_ids", + "required": false, + "description": "Comma separated encoded channel IDs for custom additions to user group members.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "additional_channels" + }, + { + "name": "user_group_description", + "required": false, + "description": "A short description of the User Group to update in Slack. This should clearly define the group's purpose or role.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "description" + }, + { + "name": "user_group_handle", + "required": false, + "description": "Unique mention handle for the User Group, distinct from all channels, users, and other User Groups.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "handle" + }, + { + "name": "user_group_name", + "required": false, + "description": "A unique name for the User Group to update. Ensure it does not duplicate any existing User Group names.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "name" + }, + { + "name": "team_id_for_org_token", + "required": false, + "description": "Encoded team ID where the user group exists, required for org-level tokens. Ignored if using a workspace-level token.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "include_user_count", + "required": false, + "description": "Set to true to include the number of users in the User Group.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_count" + }, + { + "name": "enable_sidebar_section", + "required": false, + "description": "Set to true to configure the user group to appear as a sidebar section for all group members. Only relevant if the group has 1 or more default channels.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "enable_section" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'usergroups.update'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "usergroups:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/usergroups.update", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "usergroup", + "tool_parameter_name": "user_group_id", + "description": "The encoded ID of the User Group to update.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "channels", + "tool_parameter_name": "default_channel_ids", + "description": "A comma separated string of encoded channel IDs for which the User Group uses as a default.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "additional_channels", + "tool_parameter_name": "additional_channel_ids", + "description": "A comma separated string of encoded channel IDs for which the User Group can custom add usergroup members too.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "description", + "tool_parameter_name": "user_group_description", + "description": "A short description of the User Group.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "handle", + "tool_parameter_name": "user_group_handle", + "description": "A mention handle. Must be unique among channels, users and User Groups.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "include_count", + "tool_parameter_name": "include_user_count", + "description": "Include the number of users in the User Group.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "name", + "tool_parameter_name": "user_group_name", + "description": "A name for the User Group. Must be unique among User Groups.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "team_id_for_org_token", + "description": "Encoded team id where the user group exists, required if org token is used", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "enable_section", + "tool_parameter_name": "enable_sidebar_section", + "description": "Configure this user group to show as a sidebar section for all group members. Note: Only relevant if group has 1 or more default channels added.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/usergroups.update" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/arcade_slack_api/wrapper_tools/UpdateSlackUsergroupUsers.json b/toolkits/slack_api/arcade_slack_api/wrapper_tools/UpdateSlackUsergroupUsers.json new file mode 100644 index 00000000..6754ebd7 --- /dev/null +++ b/toolkits/slack_api/arcade_slack_api/wrapper_tools/UpdateSlackUsergroupUsers.json @@ -0,0 +1,269 @@ +{ + "name": "UpdateSlackUsergroupUsers", + "fully_qualified_name": "SlackApi.UpdateSlackUsergroupUsers@0.1.0", + "description": "Update the list of users in a Slack user group.\n\nThis tool updates the list of users for a specified Slack user group. It should be called when changes to the membership of a Slack user group are required.", + "toolkit": { + "name": "ArcadeSlackApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "user_group_id", + "required": true, + "description": "The encoded ID of the Slack user group to update.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "usergroup" + }, + { + "name": "user_ids_list", + "required": true, + "description": "A comma separated string of encoded Slack user IDs representing the complete user list for the group. This replaces all current members.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "users" + }, + { + "name": "team_id_for_org_token", + "required": false, + "description": "Encoded team ID where the user group exists. Required if using an organization token; ignored with workspace-level token.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "team_id" + }, + { + "name": "update_additional_channels", + "required": false, + "description": "Encoded channel IDs to add user group members to, separated by commas. These represent additional channels for custom user group member additions.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "additional_channels" + }, + { + "name": "include_user_count", + "required": false, + "description": "Set to true to include the number of users in the user group in the response.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_count" + }, + { + "name": "is_shared_section", + "required": false, + "description": "Indicates if the API call involves a shared section. Set to true if it does, otherwise false.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "inferrable": true, + "http_endpoint_parameter_name": "is_shared" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'usergroups.users.update'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": { + "provider_id": "arcade-slack", + "provider_type": "oauth2", + "id": null, + "oauth2": { + "scopes": [ + "usergroups:write" + ] + } + }, + "secrets": null, + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.0.0", + "description": "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.0.0", + "description": "" + }, + "url": "https://slack.com/api/usergroups.users.update", + "http_method": "POST", + "headers": { + "Content-Type": "application/x-www-form-urlencoded" + }, + "parameters": [ + { + "name": "usergroup", + "tool_parameter_name": "user_group_id", + "description": "The encoded ID of the user group to update.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "users", + "tool_parameter_name": "user_ids_list", + "description": "A comma separated string of encoded user IDs that represent the entire list of users for the user group.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "include_count", + "tool_parameter_name": "include_user_count", + "description": "Include the number of users in the user group.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "team_id", + "tool_parameter_name": "team_id_for_org_token", + "description": "Encoded team id where the user group exists, required if org token is used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "additional_channels", + "tool_parameter_name": "update_additional_channels", + "description": "A comma separated string of encoded channel IDs for which the User Group can custom add usergroup members to.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + }, + { + "name": "is_shared", + "tool_parameter_name": "is_shared_section", + "description": "Boolean to identify if the API is getting called when a shared section is getting shared", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "documentation_urls": [] + } + ], + "documentation_urls": [ + "https://docs.slack.dev/reference/methods/usergroups.users.update" + ], + "secrets": [ + { + "arcade_key": "auth_token", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": "Bearer {authorization}", + "description": "The OAuth token to use for authentication.", + "is_auth_token": true + } + ] + } +} diff --git a/toolkits/slack_api/pyproject.toml b/toolkits/slack_api/pyproject.toml new file mode 100644 index 00000000..f649ce85 --- /dev/null +++ b/toolkits/slack_api/pyproject.toml @@ -0,0 +1,61 @@ +[build-system] +requires = [ "hatchling",] +build-backend = "hatchling.build" + +[project] +name = "arcade_slack_api" +version = "0.1.0" +description = "Arcade Wrapper Tools enabling LLMs to interact with low-level Slack API endpoints." +requires-python = ">=3.10" +dependencies = [ + "arcade-tdk>=2.0.0,<3.0.0", + "httpx>=0.27.2,<1.0.0", +] +[[project.authors]] +name = "Arcade" +email = "support@arcade.dev" + + +[project.optional-dependencies] +dev = [ + "arcade-ai[evals]>=2.2.2,<3.0.0", + "arcade-serve>=2.0.0,<3.0.0", + "pytest>=8.3.0,<8.4.0", + "pytest-cov>=4.0.0,<4.1.0", + "pytest-mock>=3.11.1,<3.12.0", + "pytest-asyncio>=0.24.0,<0.25.0", + "mypy>=1.5.1,<1.6.0", + "pre-commit>=3.4.0,<3.5.0", + "tox>=4.11.1,<4.12.0", + "ruff>=0.7.4,<0.8.0", +] + +# Tell Arcade.dev that this package is a toolkit +[project.entry-points.arcade_toolkits] +toolkit_name = "arcade_slack_api" + +# Use local path sources for arcade libs when working locally +[tool.uv.sources] +arcade-ai = { path = "../../", editable = true } +arcade-serve = { path = "../../libs/arcade-serve/", editable = true } +arcade-tdk = { path = "../../libs/arcade-tdk/", editable = true } +[tool.mypy] +files = [ "arcade_slack_api/**/*.py",] +python_version = "3.10" +disallow_untyped_defs = "True" +disallow_any_unimported = "True" +no_implicit_optional = "True" +check_untyped_defs = "True" +warn_return_any = "True" +warn_unused_ignores = "True" +show_error_codes = "True" +ignore_missing_imports = "True" + +[tool.pytest.ini_options] +testpaths = [ "tests",] + +[tool.coverage.report] +skip_empty = true + +[tool.hatch.build.targets.wheel] +packages = [ "arcade_slack_api",] diff --git a/toolkits/slack_api/tests/__init__.py b/toolkits/slack_api/tests/__init__.py new file mode 100644 index 00000000..e69de29b