Werify

Backfill a captured conversation's earlier history from the phone, down to `from_date` (or all of it), in the window `backfill_preview` showed. Echo its `message_count` for the same `from_date`. Set `transcribed_audio_count` to that option's `audio_count` when `transcribe` is true, or 0 when false, and echo any coverage flag the preview returned. The backfill is refused if the consent no longer matches, and the refusal carries what the window holds now, to show and confirm again. This is the step that draws on the user's balance: never call it without having shown the user what it brings in and had them agree. Messages then arrive over the next minutes. If this tool answers an error whose code is `currency_selection_required`, the user has not confirmed the account's currency: show them the `action_url` and do not retry until they say it is done.

request_backfill

Connect a WhatsApp number to the user's Werify account by pairing code — no QR, no browser. Ask the user for their WhatsApp number with country code (never infer it), call this, then relay the `instructions`: the phone gets a WhatsApp notification to link a device, or the user opens WhatsApp → Linked devices → Link a device → Link with phone number, and types the code. The code is valid for about 2.5 minutes; if it expires, call again for a new one. The pairing completes on the phone, not here: confirm it with `list_connected_numbers` (`linking` → `syncing` → `ready`). A number the user had connected before and that dropped is reconnected in place (`reconnecting: true`) — nothing is lost. Connecting is free. Once `capture_funded` is true, capture can start here through `list_capturable_chats` and `start_capture`. A number owned by another Werify account is refused without revealing that account; its phone-verified transfer flow is deliberately completed in the web app. If this tool answers an error whose code is `currency_selection_required`, the user has not confirmed the account's currency: show them the `action_url` and do not retry until they say it is done.

connect_whatsapp_number

Find the user's conversations by **name** and return summaries — id, name, message count, participants and date range. Omit `query` (or pass it empty) to list the most recent conversations. Pass an id from the results to `get_conversation` to read the transcript, or to `search_messages` to search the message text inside it. This matches conversation names only, not message content. Only conversations the user owns or has been shared are accessible.

search_conversations

Get a temporary download URL for one attachment by media_id from list_attachments (or the id in a /media/<id> URL). Call only when the user requests that individual file. The URL downloads the original bytes without an Authorization header or browser session. Anyone holding the URL can download that file until expires_at; do not publish it or include it in shared documents. Request a new URL if it expires. No OAuth bearer is exposed. Only accessible, stored media is available. This returns a download URL, not a ChatGPT file_id; another tool must support fetching the URL to use or transfer the file.

get_attachment_file

List one conversation's media attachments — images, documents, audio, video, stickers — **most recent first**, cursor-paginated, each entry carrying the URL that serves the raw file. Only attachments whose bytes Werify actually holds are listed. Filter with `type` and/or a `start_date`/`end_date` window ("the invoice they sent in July" → `type: "document"` + the July window). The `url` serves the file over plain HTTPS: it accepts this MCP server's own `Authorization: Bearer` token — a client that can make HTTP requests fetches it directly and can analyze images and PDFs — and in a browser it opens with the user's Werify login, so a client that cannot fetch URLs should hand the link to the user. Audio content is better read as inline transcripts via `get_conversation`. Only conversations the user owns or has been shared are accessible.

list_attachments

List the chats a connected WhatsApp number can capture — the phone's own conversation list, newest activity first — with each chat's `chat_jid` (what `start_capture` takes) and, when Werify already captures it, the `conversation_id` the read tools use and whether the capture is running or stopped. Filter by name with `query`; large lists page with `cursor`. Pass the `phone` from `list_connected_numbers`.

list_capturable_chats

List the WhatsApp numbers connected to the user's Werify account, with each one's status. Use it after `connect_whatsapp_number` to confirm the pairing landed (`linking` → `syncing` → `ready`), and before telling the user what a number can do. A number is keyed by its phone; a `linking` entry with no phone is a pairing still waiting for its code. `ready` means the initial sync finished and the number can capture conversations through `start_capture` when `capture_funded` is true. When it is false, `funding_hint` says what the user has to do and where.

list_connected_numbers

Read one conversation's transcript by id (from `search_conversations`), one page at a time, **most recent first**. Page one is the newest window of messages; pass `cursor` (the `next_cursor` from the previous page) to walk *backward* into older history, a `null` `next_cursor` meaning you've reached the start of the conversation. Within each page the messages are in chronological order (oldest→newest) with timestamps, senders and audio transcripts, so a page reads naturally. Optionally bound the range with `start_date` / `end_date` — the cursor already carries that range, so you do not re-send the dates when paging. Only conversations the user owns or has been shared are accessible.

get_conversation

Search *within* one conversation and return the messages whose text — the message content or an audio message's transcript — matches `query`. Matches come back **most recent first** with timestamps and senders, so the latest activity is on the first page. Optionally bound the search to a `start_date` / `end_date` window (e.g. "what came up this week"). Pass `cursor` (the `next_cursor` from the previous page) to continue — it already carries the `query` and date range, so you do not re-send them; a `null` `next_cursor` means the end. Use `search_conversations` first to find the conversation's id. Only conversations the user owns or has been shared are accessible.

search_messages

Send a text message into one of the user's conversations, from the user's own WhatsApp number. Only a conversation under **active capture** can be written to — the same ones whose new messages you can already read; anything else is refused server-side. Confirm the exact text with the user before calling this: the message is sent immediately and reaches the other person's phone — there is no draft step and no undo. Send one message to one conversation at a time; never use this in bulk. `conversation_id` is the id the read tools return. Retrying the same text moments later is deduplicated server-side and answered as success with `duplicate: true` — do not retry by rephrasing.

send_message