Knock

This is the Management API: workflows, channels, templates, commits, and configuration. This session allows **read and write**. Use `execute_mapi_read` for `GET` and `execute_mapi_write` for `POST`/`PUT`/`PATCH`/`DELETE`. Use this tool (Code Mode: `execute_mapi_read`) for **read-only** `MAPI` calls at https://control.knock.app via `mapi.request({ method: "GET", ... })`. Use `search_mapi` first to find paths and request shapes. Auth headers are added on the host. For create/update/delete, use `execute_mapi_write` instead. **mapi.request() response shape:** does NOT return the API JSON body directly. It wraps it: ```json { "status": 200, "ok": true, "result": { /* actual API response body */ } } ``` Always read API fields from `res.result`, not from `res` (e.g. `res.result.entries`, not `res.entries`). When the user asks for the "exact result," return the full `mapi.request(...)` value unless they ask for a projection. Types: interface RequestOptions { method: "GET"; path: string; query?: Record<string, string | number | boolean | undefined>; headers?: Record<string, string>; } /** Wrapper returned by mapi.request() — the API body is in `result`, not at the top level. */ interface RequestResponse { status: number; ok: boolean; result: unknown; } declare const mapi: { request(options: RequestOptions): Promise<RequestResponse> }; Your code must be a single JavaScript async arrow function (no TypeScript). Example: async () => { const res = await mapi.request({ method: "GET", path: "/v1/workflows", query: { environment: "development" }, }); return { status: res.status, entries: res.result.entries, page_info: res.result.page_info }; }

execute_mapi_read

This is the Management API: workflows, channels, templates, commits, and configuration. This session allows **read and write**. Use `execute_mapi_read` for `GET` and `execute_mapi_write` for `POST`/`PUT`/`PATCH`/`DELETE`. Use this tool (Code Mode: `execute_mapi_write`) for **write** `MAPI` calls at https://control.knock.app via `mapi.request({ method: "POST"|"PUT"|"PATCH"|"DELETE", ... })`. Use `search_mapi` first to find paths and request shapes. Auth headers are added on the host. For `GET`, use `execute_mapi_read` instead. **mapi.request() response shape:** does NOT return the API JSON body directly. It wraps it: ```json { "status": 200, "ok": true, "result": { /* actual API response body */ } } ``` Always read API fields from `res.result`, not from `res` (e.g. `res.result.entries`, not `res.entries`). When the user asks for the "exact result," return the full `mapi.request(...)` value unless they ask for a projection. Types: interface RequestOptions { method: "POST" | "PUT" | "PATCH" | "DELETE"; path: string; query?: Record<string, string | number | boolean | undefined>; body?: unknown; contentType?: string; rawBody?: boolean; headers?: Record<string, string>; } /** Wrapper returned by mapi.request() — the API body is in `result`, not at the top level. */ interface RequestResponse { status: number; ok: boolean; result: unknown; } declare const mapi: { request(options: RequestOptions): Promise<RequestResponse> }; Your code must be a single JavaScript async arrow function (no TypeScript). Example: async () => { const res = await mapi.request({ method: "PUT", path: "/v1/workflows/welcome", query: { environment: "development" }, body: { name: "Welcome", steps: [] }, }); return { status: res.status, result: res.result }; }

execute_mapi_write

Poll an in-progress Knock agent session and return a consolidated result (agent text, tool calls, modified resources, and a Status line). When to use: - After start_knock_agent returns Status: running. - When resuming after an MCP disconnect (you still have the session_id). How to use: 1. Call with the session_id from start_knock_agent (or a prior get_knock_agent). 2. Read the Status line in the tool result — you do not parse raw events; the server consolidates them for you. 3. If Status is running, wait a few seconds and call get_knock_agent again with the same session_id. 4. If Status is complete, the run succeeded — use the agent response. 5. If Status is error, the run failed — read the Error line. The Knock agent keeps running on the backend between your polls; each call is short-lived.

get_knock_agent

Retrieves a single message by its ID, including its current status and engagement statuses (e.g. seen, read, interacted, link_clicked). Use this tool when you need to check the delivery status or engagement state of a specific message.

get_message

Retrieves the complete contents of a single message, specified by the messageId. The message contents includes the rendered template that was sent to the recipient. Use this tool when you want to surface information about the emails, SMS, and push notifications that were sent to a user.

get_message_content

Retrieves the delivery logs for a specific message. Delivery logs contain details about each delivery attempt, including any errors that occurred. Use this tool when you need to debug why a message was not delivered or to inspect delivery attempt details.

get_message_delivery_logs

Retrieves the event timeline for a specific message. Events include delivery, bounce, open, click, and other engagement events. Use this tool when you need to see the full lifecycle of a message.

get_message_events

Lists all environments available, returning the slug and name of each environment. Use this tool when you need to see what environments are available.

list_environments

This is the Management API: workflows, channels, templates, commits, and configuration. This session allows **read and write**. Use `execute_mapi_read` for `GET` and `execute_mapi_write` for `POST`/`PUT`/`PATCH`/`DELETE`. Use `search_mapi` to explore or filter the OpenAPI spec for the **mapi** API before calling `execute_mapi_read` or `execute_mapi_write`. All $ref pointers are pre-resolved inline. Types: // OpenAPI 3.x spec with $refs resolved inline. interface OperationObject { summary?: string; description?: string; operationId?: string; tags?: string[]; parameters?: Array<{ name: string; in: "query" | "header" | "path" | "cookie"; required?: boolean; schema?: unknown; description?: string; }>; requestBody?: { required?: boolean; content?: Record<string, { schema?: unknown }> }; responses?: Record<string, { content?: Record<string, { schema?: unknown }> }>; } interface PathItem { get?: OperationObject; post?: OperationObject; put?: OperationObject; patch?: OperationObject; delete?: OperationObject; } interface OpenApiSpec { openapi: string; info: { title: string; version: string; description?: string }; paths: Record<string, PathItem>; servers?: Array<{ url: string }>; components?: Record<string, unknown>; tags?: Array<{ name: string; description?: string }>; } declare const mapi: { spec(): Promise<OpenApiSpec> }; Your code must be a single JavaScript async arrow function (no TypeScript) that returns a small, filtered result. Example: async () => { const spec = await mapi.spec(); return Object.keys(spec.paths).slice(0, 20); }

search_mapi

Search the Knock documentation for a given query

search_documentation