# slack

> 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.

| field | value |
|-------|-------|
| version | 0.1.6 |
| type | binary |
| repo | https://github.com/iii-hq/workers |
| supported_targets | x86_64-apple-darwin, aarch64-apple-darwin, i686-pc-windows-msvc, x86_64-pc-windows-msvc, aarch64-pc-windows-msvc, x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, x86_64-unknown-linux-musl, armv7-unknown-linux-gnueabihf |
| author | iii |

## installation

```sh
iii worker add slack@0.1.6
```

## dependencies

- `configuration` @ `^0.21.6`
- `state` @ `^0.21.0`
- `harness` @ `^1.0.0`
- `session-manager` @ `^1.0.0`

## readme

# 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

```bash
# 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:

```yaml
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

```yaml
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

```bash
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
{
  "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": []
}
```