skip to content
iii / worker
$worker

slack

v0.1.7

Slack as an iii worker — exposes the Slack Web API as slack::* functions, plus a harness bridge (inbound events → harness::send, native streaming, approvals). Configurable from the console.

iiiverified
5 installs0 in 7d0 today
install
$iii worker add slack
binaryslackmessagingchatbotapprovals
  • macOS: arm64 · x64
  • Linux: arm64 · armv7 · x64
  • Windows: arm64 · x64 · x86
51functions0triggers1skills4depsv0.1.7version
repoiii-hq/workers

exact versions are immutable; binary and bundle artifacts are digest-pinned.

agent-ready brief for v0.1.7
install + config + dependencies + readme + api reference, all in one place. fetch as agent-context.md for an llm to consume.

full markdown

open as agent-context.md
the same content rendered as discrete blocks below is exposed as a single markdown document at /workers/slack.md. paste it into an llm prompt or pipe it through curl from a worker.

install

install
$iii worker add slack@0.1.7

dependencies

dependencies4
configuration^0.21.6state^0.21.2harness^1.0.0session-manager^1.0.0

readme

README.md

slack

Slack as an iii worker. Two surfaces in one worker:

  1. Slack Web API as slack::* functions — agent-callable and console-callable, so anything you can do through the Slack API you can do through this worker. Needs only a bot token; plain outbound HTTPS, no ingress.
  2. Harness bridge — @mention the bot in Slack and it runs a harness::send turn, streaming the reply back into the thread using Slack's native streaming (chat.startStream/appendStream/stopStream), with inline Block Kit approvals. The bridge is additive: it activates only when a public engine URL + signing secret are configured and the harness stack is connected.

Install

# API surface only:
iii worker add slack
# For the bridge, also install the harness stack and console:
iii worker add harness console

Configure

Set a bot token (and optionally a user token for search) in the console Configuration → Workers → slack, or seed it from the environment:

bot_token: "${SLACK_BOT_TOKEN}"   # xoxb-, required
user_token: "${SLACK_USER_TOKEN}" # xoxp-, optional (only slack::search::messages)
timeout_ms: 10000

Identity (workspace, team id, bot user) is not configured — it is discovered at boot via auth.test and reported by slack::config-status. All fields hot-reload through the configuration worker; no restart.

Run slack::config-status to verify the token and see the resolved identity.

Enable the bridge

signing_secret: "${SLACK_SIGNING_SECRET}"      # required for the bridge
public_base_url: "https://your-engine.example" # Slack posts events here
require_mention: true        # channels fire only on @bot mention (DMs always)
backfill_thread: true        # pull prior thread replies into the session on first mention
default_model: null          # optional; else the first model from router::models::list
functions_allow: ["slack::*"]

Point the Slack app's Event Subscriptions request URL at {public_base_url}/slack/events and the Interactivity request URL at {public_base_url}/slack/interactions. Subscribe to app_mention, message.im, message.channels, and assistant_thread_started. Every inbound request is HMAC-verified against signing_secret.

Triggering: in channels the bot acts only when explicitly @mentioned; untagged messages are captured as thread context and folded into the next mention. DMs always trigger. Sessions are keyed per thread.

Functions

Messaging — slack::chat::post-message · update · delete · post-ephemeral · schedule-message · get-permalink

Conversations — slack::conversations::list · info · history · replies · create · invite · join · members · open · set-topic · set-purpose · archive

Reactions — slack::reactions::add · remove · get

Files — slack::files::upload (reserve URL → upload bytes → finalize) · info · list

Users — slack::users::list · info · lookup-by-email · profile-get

Views — slack::views::open · publish · update · push

Pins / bookmarks — slack::pins::add · list · slack::bookmarks::add

Search — slack::search::messages (requires user_token)

Assistant — slack::assistant::set-status · set-title · set-suggested-prompts

Admin — slack::auth::test · slack::config-status

Escape hatch — slack::call { method, params, as_user? } calls any Slack Web API method by name, so every method is reachable even before it has a typed wrapper.

Bridge — slack::notify { session_id, text|blocks } reaches the Slack thread bound to a session out-of-band (e.g. a scheduled reminder). slack::events and slack::interactions are the HMAC-verified HTTP ingress endpoints; the slack::on-* functions are internal bindings that stream harness output and post approvals.

Typed functions accept the well-known parameters explicitly and pass any additional Slack parameters through. Each returns the full Slack response payload.

Local development

cargo run -- --url ws://127.0.0.1:49134 --config ./config.collect.yaml
cargo test
cargo fmt --check
cargo clippy --all-targets --all-features -- -D warnings

api reference (json)

agent-api-reference.json
{
  "functions": [
    {
      "description": "Set the assistant-thread status (the thinking indicator).",
      "metadata": {},
      "name": "slack::assistant::set-status",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "channel_id": {
            "type": "string"
          },
          "status": {
            "description": "Status text, e.g. `\"is thinking...\"`. Empty string clears it.",
            "type": "string"
          },
          "thread_ts": {
            "type": "string"
          }
        },
        "required": [
          "channel_id",
          "status",
          "thread_ts"
        ],
        "title": "SetStatusReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Set suggested prompts for an assistant thread (≤4).",
      "metadata": {},
      "name": "slack::assistant::set-suggested-prompts",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "definitions": {
          "SuggestedPrompt": {
            "properties": {
              "message": {
                "description": "Text sent to the assistant when the prompt is clicked.",
                "type": "string"
              },
              "title": {
                "description": "Clickable label shown to the user.",
                "type": "string"
              }
            },
            "required": [
              "message",
              "title"
            ],
            "type": "object"
          }
        },
        "properties": {
          "channel_id": {
            "type": "string"
          },
          "prompts": {
            "description": "Up to 4 prompts.",
            "items": {
              "$ref": "#/definitions/SuggestedPrompt"
            },
            "type": "array"
          },
          "thread_ts": {
            "type": "string"
          },
          "title": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "required": [
          "channel_id",
          "prompts",
          "thread_ts"
        ],
        "title": "SetSuggestedPromptsReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Set the assistant-thread title.",
      "metadata": {},
      "name": "slack::assistant::set-title",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "channel_id": {
            "type": "string"
          },
          "thread_ts": {
            "type": "string"
          },
          "title": {
            "type": "string"
          }
        },
        "required": [
          "channel_id",
          "thread_ts",
          "title"
        ],
        "title": "SetTitleReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Check the bot token and return the bot/workspace identity (auth.test).",
      "metadata": {},
      "name": "slack::auth::test",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "title": "AuthTestReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Add a bookmark to a channel.",
      "metadata": {},
      "name": "slack::bookmarks::add",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "channel_id": {
            "type": "string"
          },
          "link": {
            "type": [
              "string",
              "null"
            ]
          },
          "title": {
            "type": "string"
          },
          "type": {
            "description": "Bookmark type, e.g. `link`.",
            "type": "string"
          }
        },
        "required": [
          "channel_id",
          "title",
          "type"
        ],
        "title": "BookmarkAddReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Call any Slack Web API method by name with arbitrary params (escape hatch).",
      "metadata": {},
      "name": "slack::call",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "as_user": {
            "default": false,
            "description": "Use the configured user token (`xoxp-`) instead of the bot token.",
            "type": "boolean"
          },
          "method": {
            "description": "Slack Web API method name, e.g. `chat.postMessage`, `team.info`.",
            "type": "string"
          },
          "params": {
            "default": null,
            "description": "Method params object (defaults to `{}`)."
          }
        },
        "required": [
          "method"
        ],
        "title": "CallReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Delete a message by ts.",
      "metadata": {},
      "name": "slack::chat::delete",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "channel": {
            "type": "string"
          },
          "ts": {
            "type": "string"
          }
        },
        "required": [
          "channel",
          "ts"
        ],
        "title": "DeleteReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Get a permalink URL for a message.",
      "metadata": {},
      "name": "slack::chat::get-permalink",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "channel": {
            "type": "string"
          },
          "message_ts": {
            "type": "string"
          }
        },
        "required": [
          "channel",
          "message_ts"
        ],
        "title": "GetPermalinkReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Post a message visible only to one user.",
      "metadata": {},
      "name": "slack::chat::post-ephemeral",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "blocks": true,
          "channel": {
            "type": "string"
          },
          "text": {
            "type": [
              "string",
              "null"
            ]
          },
          "thread_ts": {
            "type": [
              "string",
              "null"
            ]
          },
          "user": {
            "description": "User who will see the ephemeral message.",
            "type": "string"
          }
        },
        "required": [
          "channel",
          "user"
        ],
        "title": "PostEphemeralReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Post a message to a channel, DM, or thread.",
      "metadata": {},
      "name": "slack::chat::post-message",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "blocks": {
            "description": "Block Kit blocks (array). Mutually exclusive with `markdown_text`."
          },
          "channel": {
            "description": "Channel, DM, or user id to post to (e.g. `C0123ABC` or `U0123ABC`).",
            "type": "string"
          },
          "markdown_text": {
            "description": "Markdown body (≤12000 chars). Mutually exclusive with `blocks`/`text`.",
            "type": [
              "string",
              "null"
            ]
          },
          "text": {
            "type": [
              "string",
              "null"
            ]
          },
          "thread_ts": {
            "description": "Parent message ts to reply in a thread.",
            "type": [
              "string",
              "null"
            ]
          }
        },
        "required": [
          "channel"
        ],
        "title": "PostMessageReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Schedule a message to post at a future time.",
      "metadata": {},
      "name": "slack::chat::schedule-message",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "blocks": true,
          "channel": {
            "type": "string"
          },
          "post_at": {
            "description": "Unix epoch seconds to post at.",
            "format": "int64",
            "type": "integer"
          },
          "text": {
            "type": [
              "string",
              "null"
            ]
          },
          "thread_ts": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "required": [
          "channel",
          "post_at"
        ],
        "title": "ScheduleMessageReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Edit an existing message by ts.",
      "metadata": {},
      "name": "slack::chat::update",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "blocks": true,
          "channel": {
            "type": "string"
          },
          "markdown_text": {
            "type": [
              "string",
              "null"
            ]
          },
          "text": {
            "type": [
              "string",
              "null"
            ]
          },
          "ts": {
            "description": "ts of the message to edit.",
            "type": "string"
          }
        },
        "required": [
          "channel",
          "ts"
        ],
        "title": "UpdateReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Validate the configured Slack credentials and report identity + health (for the console badge).",
      "metadata": {},
      "name": "slack::config-status",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "title": "ConfigStatusReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "bot_id": {
            "type": [
              "string",
              "null"
            ]
          },
          "bot_user_id": {
            "type": [
              "string",
              "null"
            ]
          },
          "bridge_enabled": {
            "description": "Whether the inbound bridge is enabled (socket or http transport configured).",
            "type": "boolean"
          },
          "enterprise_id": {
            "type": [
              "string",
              "null"
            ]
          },
          "error": {
            "type": [
              "string",
              "null"
            ]
          },
          "ok": {
            "description": "True when the configured bot_token authenticates against Slack.",
            "type": "boolean"
          },
          "team": {
            "type": [
              "string",
              "null"
            ]
          },
          "team_id": {
            "type": [
              "string",
              "null"
            ]
          },
          "url": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "required": [
          "bridge_enabled",
          "ok"
        ],
        "title": "ConfigStatus",
        "type": "object"
      }
    },
    {
      "description": "Archive a channel.",
      "metadata": {},
      "name": "slack::conversations::archive",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "channel": {
            "type": "string"
          }
        },
        "required": [
          "channel"
        ],
        "title": "ChannelReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Create a channel.",
      "metadata": {},
      "name": "slack::conversations::create",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "is_private": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "name": {
            "type": "string"
          }
        },
        "required": [
          "name"
        ],
        "title": "CreateReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Fetch a conversation's message history.",
      "metadata": {},
      "name": "slack::conversations::history",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "channel": {
            "type": "string"
          },
          "cursor": {
            "type": [
              "string",
              "null"
            ]
          },
          "latest": {
            "type": [
              "string",
              "null"
            ]
          },
          "limit": {
            "format": "uint32",
            "minimum": 0,
            "type": [
              "integer",
              "null"
            ]
          },
          "oldest": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "required": [
          "channel"
        ],
        "title": "HistoryReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Get metadata for one conversation.",
      "metadata": {},
      "name": "slack::conversations::info",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "channel": {
            "type": "string"
          }
        },
        "required": [
          "channel"
        ],
        "title": "ChannelReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Invite users to a channel.",
      "metadata": {},
      "name": "slack::conversations::invite",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "channel": {
            "type": "string"
          },
          "users": {
            "description": "Comma-separated user ids.",
            "type": "string"
          }
        },
        "required": [
          "channel",
          "users"
        ],
        "title": "InviteReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Join a public channel.",
      "metadata": {},
      "name": "slack::conversations::join",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "channel": {
            "type": "string"
          }
        },
        "required": [
          "channel"
        ],
        "title": "ChannelReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "List channels/DMs the bot can see.",
      "metadata": {},
      "name": "slack::conversations::list",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "cursor": {
            "type": [
              "string",
              "null"
            ]
          },
          "exclude_archived": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "limit": {
            "format": "uint32",
            "minimum": 0,
            "type": [
              "integer",
              "null"
            ]
          },
          "types": {
            "description": "Comma-separated types: `public_channel,private_channel,mpim,im`.",
            "type": [
              "string",
              "null"
            ]
          }
        },
        "title": "ListReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "List member ids of a conversation.",
      "metadata": {},
      "name": "slack::conversations::members",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "channel": {
            "type": "string"
          }
        },
        "required": [
          "channel"
        ],
        "title": "ChannelReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Open/return a DM or MPIM channel.",
      "metadata": {},
      "name": "slack::conversations::open",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "channel": {
            "type": [
              "string",
              "null"
            ]
          },
          "users": {
            "description": "Comma-separated user ids to open a DM/MPIM with.",
            "type": [
              "string",
              "null"
            ]
          }
        },
        "title": "OpenReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Fetch the replies in a thread.",
      "metadata": {},
      "name": "slack::conversations::replies",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "channel": {
            "type": "string"
          },
          "cursor": {
            "type": [
              "string",
              "null"
            ]
          },
          "limit": {
            "format": "uint32",
            "minimum": 0,
            "type": [
              "integer",
              "null"
            ]
          },
          "ts": {
            "description": "Parent thread ts.",
            "type": "string"
          }
        },
        "required": [
          "channel",
          "ts"
        ],
        "title": "RepliesReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Set a channel purpose.",
      "metadata": {},
      "name": "slack::conversations::set-purpose",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "channel": {
            "type": "string"
          },
          "purpose": {
            "type": "string"
          }
        },
        "required": [
          "channel",
          "purpose"
        ],
        "title": "SetPurposeReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Set a channel topic.",
      "metadata": {},
      "name": "slack::conversations::set-topic",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "channel": {
            "type": "string"
          },
          "topic": {
            "type": "string"
          }
        },
        "required": [
          "channel",
          "topic"
        ],
        "title": "SetTopicReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Slack Events API ingress (signature-verified).",
      "metadata": {},
      "name": "slack::events",
      "request_schema": {
        "description": "Published request shape for `slack::events` (an HTTP trigger payload). The handler reads the raw body from the request channel; this typed struct exists so the function publishes a typed schema rather than AnyValue.",
        "properties": {
          "body": {
            "default": null,
            "description": "The Slack event envelope (also delivered raw on the request_body channel)."
          }
        },
        "title": "EventsHttpRequest",
        "type": "object"
      },
      "response_schema": {
        "type": "null"
      }
    },
    {
      "description": "Get metadata for a file.",
      "metadata": {},
      "name": "slack::files::info",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "file": {
            "type": "string"
          }
        },
        "required": [
          "file"
        ],
        "title": "InfoReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "List files visible to the bot.",
      "metadata": {},
      "name": "slack::files::list",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "channel": {
            "type": [
              "string",
              "null"
            ]
          },
          "user": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "title": "ListReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Upload a file (reserve URL, upload bytes, finalize) and optionally share it to a channel.",
      "metadata": {},
      "name": "slack::files::upload",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "channel_id": {
            "description": "Channel id to share the file into.",
            "type": [
              "string",
              "null"
            ]
          },
          "content": {
            "description": "UTF-8 text content. Provide this OR `content_base64`.",
            "type": [
              "string",
              "null"
            ]
          },
          "content_base64": {
            "description": "Base64-encoded binary content. Provide this OR `content`.",
            "type": [
              "string",
              "null"
            ]
          },
          "filename": {
            "type": "string"
          },
          "initial_comment": {
            "type": [
              "string",
              "null"
            ]
          },
          "thread_ts": {
            "type": [
              "string",
              "null"
            ]
          },
          "title": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "required": [
          "filename"
        ],
        "title": "UploadReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "file_id": {
            "type": "string"
          },
          "ok": {
            "type": "boolean"
          }
        },
        "required": [
          "file_id",
          "ok"
        ],
        "title": "UploadResponse",
        "type": "object"
      }
    },
    {
      "description": "Slack interactivity ingress (block actions / view submissions).",
      "metadata": {},
      "name": "slack::interactions",
      "request_schema": {
        "description": "Published request shape for `slack::interactions` (an HTTP trigger payload). The handler reads the raw form body from the request channel; this typed struct exists so the function publishes a typed schema rather than AnyValue.",
        "properties": {
          "body": {
            "default": null,
            "description": "The url-encoded interactivity body (also delivered raw on the request_body channel)."
          }
        },
        "title": "InteractionsHttpRequest",
        "type": "object"
      },
      "response_schema": {
        "type": "null"
      }
    },
    {
      "description": "Send a message to the Slack thread bound to a session (out-of-band, e.g. a reminder).",
      "metadata": {},
      "name": "slack::notify",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "blocks": {
            "default": null,
            "description": "Optional Block Kit blocks."
          },
          "session_id": {
            "description": "A session this bot created (its replies are bound to a Slack thread).",
            "type": "string"
          },
          "text": {
            "default": null,
            "description": "Message text (markdown). Used unless `blocks` is provided.",
            "type": [
              "string",
              "null"
            ]
          }
        },
        "required": [
          "session_id"
        ],
        "title": "NotifyRequest",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "channel": {
            "type": "string"
          },
          "delivered": {
            "type": "boolean"
          },
          "ts": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "required": [
          "channel",
          "delivered"
        ],
        "title": "NotifyResponse",
        "type": "object"
      }
    },
    {
      "description": "Internal: reload slack configuration from the authoritative store on change.",
      "metadata": {},
      "name": "slack::on-config-change",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "title": "ConfigChangeRequest",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "ok": {
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "ConfigChangeAck",
        "type": "object"
      }
    },
    {
      "description": "Seed the Slack stream for a new assistant entry.",
      "metadata": {},
      "name": "slack::on-message-added",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "definitions": {
          "AgentMessage": {
            "properties": {
              "content": {
                "items": {
                  "$ref": "#/definitions/ContentBlock"
                },
                "type": "array"
              },
              "role": {
                "type": "string"
              }
            },
            "required": [
              "role"
            ],
            "type": "object"
          },
          "ContentBlock": {
            "oneOf": [
              {
                "properties": {
                  "text": {
                    "type": "string"
                  },
                  "type": {
                    "enum": [
                      "text"
                    ],
                    "type": "string"
                  }
                },
                "required": [
                  "text",
                  "type"
                ],
                "type": "object"
              },
              {
                "properties": {
                  "text": {
                    "type": "string"
                  },
                  "type": {
                    "enum": [
                      "thinking"
                    ],
                    "type": "string"
                  }
                },
                "required": [
                  "text",
                  "type"
                ],
                "type": "object"
              },
              {
                "properties": {
                  "function_id": {
                    "type": "string"
                  },
                  "type": {
                    "enum": [
                      "function_call"
                    ],
                    "type": "string"
                  }
                },
                "required": [
                  "function_id",
                  "type"
                ],
                "type": "object"
              },
              {
                "properties": {
                  "type": {
                    "enum": [
                      "other"
                    ],
                    "type": "string"
                  }
                },
                "required": [
                  "type"
                ],
                "type": "object"
              }
            ]
          }
        },
        "properties": {
          "entry_id": {
            "type": "string"
          },
          "message": {
            "anyOf": [
              {
                "$ref": "#/definitions/AgentMessage"
              },
              {
                "type": "null"
              }
            ]
          },
          "session_id": {
            "type": "string"
          }
        },
        "required": [
          "entry_id",
          "session_id"
        ],
        "title": "MessageAddedEvent",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "ok": {
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "BindingAck",
        "type": "object"
      }
    },
    {
      "description": "Stream assistant text revisions into Slack.",
      "metadata": {},
      "name": "slack::on-message-updated",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "definitions": {
          "AgentMessage": {
            "properties": {
              "content": {
                "items": {
                  "$ref": "#/definitions/ContentBlock"
                },
                "type": "array"
              },
              "role": {
                "type": "string"
              }
            },
            "required": [
              "role"
            ],
            "type": "object"
          },
          "ContentBlock": {
            "oneOf": [
              {
                "properties": {
                  "text": {
                    "type": "string"
                  },
                  "type": {
                    "enum": [
                      "text"
                    ],
                    "type": "string"
                  }
                },
                "required": [
                  "text",
                  "type"
                ],
                "type": "object"
              },
              {
                "properties": {
                  "text": {
                    "type": "string"
                  },
                  "type": {
                    "enum": [
                      "thinking"
                    ],
                    "type": "string"
                  }
                },
                "required": [
                  "text",
                  "type"
                ],
                "type": "object"
              },
              {
                "properties": {
                  "function_id": {
                    "type": "string"
                  },
                  "type": {
                    "enum": [
                      "function_call"
                    ],
                    "type": "string"
                  }
                },
                "required": [
                  "function_id",
                  "type"
                ],
                "type": "object"
              },
              {
                "properties": {
                  "type": {
                    "enum": [
                      "other"
                    ],
                    "type": "string"
                  }
                },
                "required": [
                  "type"
                ],
                "type": "object"
              }
            ]
          }
        },
        "properties": {
          "entry_id": {
            "type": "string"
          },
          "message": {
            "$ref": "#/definitions/AgentMessage"
          },
          "revision": {
            "format": "uint64",
            "minimum": 0,
            "type": "integer"
          },
          "session_id": {
            "type": "string"
          }
        },
        "required": [
          "entry_id",
          "message",
          "revision",
          "session_id"
        ],
        "title": "MessageUpdatedEvent",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "ok": {
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "BindingAck",
        "type": "object"
      }
    },
    {
      "description": "Post an inline Block Kit approval when a tool call is held.",
      "metadata": {},
      "name": "slack::on-pending-created",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "arguments_excerpt": {
            "default": null
          },
          "function_call_id": {
            "type": "string"
          },
          "function_id": {
            "type": "string"
          },
          "session_id": {
            "type": "string"
          }
        },
        "required": [
          "function_call_id",
          "function_id",
          "session_id"
        ],
        "title": "PendingApprovalRecord",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "ok": {
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "BindingAck",
        "type": "object"
      }
    },
    {
      "description": "Observe approval resolution (button click already cleared the prompt).",
      "metadata": {},
      "name": "slack::on-pending-resolved",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "function_call_id": {
            "type": "string"
          },
          "outcome": {
            "default": null,
            "type": [
              "string",
              "null"
            ]
          },
          "session_id": {
            "type": "string"
          }
        },
        "required": [
          "function_call_id",
          "session_id"
        ],
        "title": "PendingResolvedEvent",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "ok": {
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "BindingAck",
        "type": "object"
      }
    },
    {
      "description": "Finalize the Slack stream and report turn errors.",
      "metadata": {},
      "name": "slack::on-turn-completed",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "reason": {
            "default": null,
            "type": [
              "string",
              "null"
            ]
          },
          "result_error": {
            "default": null,
            "type": [
              "string",
              "null"
            ]
          },
          "session_id": {
            "type": "string"
          },
          "status": {
            "type": "string"
          },
          "terminal": {
            "default": true,
            "description": "`false` while the session still owns an armed wake: the run continues and a later turn carries the real outcome. Missing (legacy harness) → terminal.",
            "type": "boolean"
          },
          "turn_id": {
            "type": "string"
          }
        },
        "required": [
          "session_id",
          "status",
          "turn_id"
        ],
        "title": "TurnCompletedEvent",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "ok": {
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "BindingAck",
        "type": "object"
      }
    },
    {
      "description": "Pin a message to a channel.",
      "metadata": {},
      "name": "slack::pins::add",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "channel": {
            "type": "string"
          },
          "timestamp": {
            "description": "Message ts to pin/unpin.",
            "type": "string"
          }
        },
        "required": [
          "channel",
          "timestamp"
        ],
        "title": "PinReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "List a channel's pinned items.",
      "metadata": {},
      "name": "slack::pins::list",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "channel": {
            "type": "string"
          }
        },
        "required": [
          "channel"
        ],
        "title": "PinsListReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Add an emoji reaction to a message.",
      "metadata": {},
      "name": "slack::reactions::add",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "channel": {
            "type": "string"
          },
          "name": {
            "description": "Emoji name without colons (e.g. `thumbsup`).",
            "type": "string"
          },
          "timestamp": {
            "description": "Message ts to react to.",
            "type": "string"
          }
        },
        "required": [
          "channel",
          "name",
          "timestamp"
        ],
        "title": "ReactionReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Get reactions on a message.",
      "metadata": {},
      "name": "slack::reactions::get",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "channel": {
            "type": "string"
          },
          "timestamp": {
            "type": "string"
          }
        },
        "required": [
          "channel",
          "timestamp"
        ],
        "title": "GetReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Remove an emoji reaction from a message.",
      "metadata": {},
      "name": "slack::reactions::remove",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "channel": {
            "type": "string"
          },
          "name": {
            "description": "Emoji name without colons (e.g. `thumbsup`).",
            "type": "string"
          },
          "timestamp": {
            "description": "Message ts to react to.",
            "type": "string"
          }
        },
        "required": [
          "channel",
          "name",
          "timestamp"
        ],
        "title": "ReactionReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Search messages (requires a configured user_token).",
      "metadata": {},
      "name": "slack::search::messages",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "count": {
            "format": "uint32",
            "minimum": 0,
            "type": [
              "integer",
              "null"
            ]
          },
          "cursor": {
            "type": [
              "string",
              "null"
            ]
          },
          "query": {
            "type": "string"
          },
          "sort": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "required": [
          "query"
        ],
        "title": "MessagesReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Get a user's profile and metadata.",
      "metadata": {},
      "name": "slack::users::info",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "user": {
            "type": "string"
          }
        },
        "required": [
          "user"
        ],
        "title": "InfoReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "List workspace users.",
      "metadata": {},
      "name": "slack::users::list",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "cursor": {
            "type": [
              "string",
              "null"
            ]
          },
          "limit": {
            "format": "uint32",
            "minimum": 0,
            "type": [
              "integer",
              "null"
            ]
          }
        },
        "title": "ListReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Find a user by email address.",
      "metadata": {},
      "name": "slack::users::lookup-by-email",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "email": {
            "type": "string"
          }
        },
        "required": [
          "email"
        ],
        "title": "LookupByEmailReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Get a user's profile fields.",
      "metadata": {},
      "name": "slack::users::profile-get",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "user": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "title": "ProfileGetReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Open a Block Kit modal.",
      "metadata": {},
      "name": "slack::views::open",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "trigger_id": {
            "description": "Interaction trigger_id (expires ~3s after the interaction).",
            "type": "string"
          },
          "view": {
            "description": "Block Kit view object."
          }
        },
        "required": [
          "trigger_id",
          "view"
        ],
        "title": "OpenReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Publish the App Home tab for a user.",
      "metadata": {},
      "name": "slack::views::publish",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "hash": {
            "type": [
              "string",
              "null"
            ]
          },
          "user_id": {
            "type": "string"
          },
          "view": {
            "description": "Block Kit view of type `home`."
          }
        },
        "required": [
          "user_id",
          "view"
        ],
        "title": "PublishReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Push a new modal onto the stack.",
      "metadata": {},
      "name": "slack::views::push",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "trigger_id": {
            "type": "string"
          },
          "view": true
        },
        "required": [
          "trigger_id",
          "view"
        ],
        "title": "PushReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    },
    {
      "description": "Update an open view.",
      "metadata": {},
      "name": "slack::views::update",
      "request_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "external_id": {
            "type": [
              "string",
              "null"
            ]
          },
          "hash": {
            "type": [
              "string",
              "null"
            ]
          },
          "view": true,
          "view_id": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "required": [
          "view"
        ],
        "title": "UpdateReq",
        "type": "object"
      },
      "response_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": true,
        "properties": {
          "ok": {
            "description": "Slack's success flag (always true here; failures surface as errors).",
            "type": "boolean"
          }
        },
        "required": [
          "ok"
        ],
        "title": "SlackResponse",
        "type": "object"
      }
    }
  ],
  "triggers": []
}