@talqing/mcp 0.3.4 → 0.5.0

package/SKILL.md

@@ -42,7 +42,9 @@ An agent is a single object, `config`, plus what you attach to it:
   Anam avatar) or `text` (chat). The channel decides which model slots exist.
 - **`prompt`** — the system prompt. This is where the agent's behaviour lives.
 - **`greeting`** — the line spoken on connect, and on the way in from a
-  handoff. Voice and video only.
+  handoff. Voice and video only. `greeting_interruptible: false` makes the
+  caller unable to cut it off (cascade only); a greeting speaking the recording
+  notice is always protected.
 
   Both are personalized per session: `{{userdata.field}}` is substituted from
   the session's userdata when the agent starts, so *"You are speaking with
@@ -97,7 +99,7 @@ An agent is a single object, `config`, plus what you attach to it:
 
   Values arrive on the **request that starts the session** — `vars` on
   `calls_token`, `create_outbound_call`, `create_call_batch` or
-  `create_text_conversation` — and override the defaults. One bag per session,
+  `create_chat` — and override the defaults. One bag per session,
   reaching *every* agent on it: the entry agent, every team member, and a handoff
   target that was never in the plan, each merged over its own declared defaults.
   Nothing inside the session can write it.
@@ -108,8 +110,8 @@ An agent is a single object, `config`, plus what you attach to it:
     repeated back. A credential belongs in a workspace secret, read as
     `{{secrets.NAME}}` from a tool, where the model never sees it.
   - **`required: true` refuses the session** that supplies no value for a
-    variable with no `default` — the call token, the dial, the batch and the text
-    conversation, before anything is compiled and before any provider is called.
+    variable with no `default` — the call token, the dial, the batch and the chat,
+    before anything is compiled and before any provider is called.
     An empty string counts as a value; a `default` satisfies it outright. Nothing
     is enforced once a session is connected, so a handoff target that needs a
     value nobody supplied reads it as empty rather than ending the call.
@@ -169,6 +171,13 @@ An agent is a single object, `config`, plus what you attach to it:
   job inside a longer call — taking an address, qualifying a lead — and a
   `handoffs` entry when the caller should belong to someone else from then on.
 
+  **Start `description` with "Handoff to an agent task responsible for …"**,
+  then say when to enter it and when to skip it: "Handoff to an agent task
+  responsible for collecting the caller's name and work email, after they've
+  agreed to a demo. Skip this if you already have both." It tells the calling
+  model this is not a lookup but an agent that takes over the conversation and
+  talks to the person until its job is done.
+
   `name` is yours, not the task's, so renaming the task never changes the tool
   name a published prompt was written against. The task must be **published**;
   publishing the agent pins the version. An entry may instead carry `{"task":
@@ -258,22 +267,44 @@ An agent is a single object, `config`, plus what you attach to it:
   scoped away. And the summary is written by an LLM the caller has been talking
   to, so it is exactly as trustworthy as anything else the model says. The one
   thing that does hold is that the source agent's raw tool results do not cross.
-- **`conversation`** — what a new call knows about earlier ones with the same
-  person: `context` is `none` (the default — every call starts clean, though
-  earlier conversations are still saved against that caller), `summary` (the
+- **`max_steps`** (1–50, `null` = 4 on voice and video, 25 on text) — how many
+  LLM → tools → LLM **rounds** one turn may take. Past it the model must answer
+  without tools, so the caller gets a thinner answer rather than an error; a
+  `tool.step_limit_reached` session event records it. Raise it when a turn
+  legitimately chains lookups; on voice every round is dead air. The agent that
+  starts the call sets it for the whole call, handoffs included. Realtime models
+  ignore it.
+- **`silence`** and **`max_duration_seconds`** — what ends a call nobody hung up.
+  Voice and video only; like `max_steps`, the agent that starts the call sets both.
+  `silence` (`enabled`, `timeout` 10 s, `max_check_ins` 2): after `timeout` seconds
+  of quiet the agent checks the caller is still there, in its own words, and after
+  the last unanswered check-in says goodbye and hangs up (close reason
+  `silence_timeout`). `max_duration_seconds` (default 1800; `null` = the platform's
+  3-hour cap): the agent says goodbye and hangs up at the limit (`max_duration`).
+  Raise either rather than turning it off when a caller legitimately goes quiet —
+  reading out a long number, or on hold with their bank.
+- **`voicemail_detection`** (`enabled`, off by default; `message`) — on calls the
+  agent places, it gets a `voicemail_detected` tool to call when a machine answers.
+  It then speaks `message` word for word (same substitutions as the greeting;
+  `null` = no message) and hangs up with close reason `voicemail`. A batch retries
+  that recipient like a missed call. Voice agents only. Turn it on for any agent
+  that makes outbound calls, and keep the message short.
+- **`conversation`** — what a new call or chat knows about earlier ones with the
+  same person: `context` is `none` (the default — each starts clean, though
+  earlier conversations are still saved against that person), `summary` (the
   agent is told, as background, what happened on recent ones) or `transcript`
-  (one long conversation across every call). `summary_limit` bounds how many
-  recent calls `summary` describes — leave it out for all of them — and
-  `initialize_userdata` decides whether the call also starts from what the agent
+  (one long conversation across every call and chat). `summary_limit` bounds how
+  many recent ones `summary` describes — leave it out for all of them — and
+  `initialize_userdata` decides whether it also starts from what the agent
   learned about this person before.
 
   This is the answer whenever someone wants an agent to remember, or to forget,
   earlier calls. **Never write that instruction into the prompt** — a model told
   to ignore what is in its context is being asked to do the impossible, and a
   model told to remember cannot see what was never loaded. Set the field.
-  `summary` needs call analysis with its summary switched on, and publish
-  refuses it otherwise. A text agent is always `transcript` and cannot be
-  changed: a chat thread has no boundary anyone would recognise.
+  `summary` needs analysis with its summary switched on, and publish refuses it
+  otherwise. All three work on text too, and a WhatsApp call always joins the
+  chat's conversation, whatever the agent answering it is set to.
 - **`on_enter`, `on_exit`, `on_user_turn_completed`** — one such tool reference
   each, run as lifecycle hooks.
 
@@ -312,8 +343,10 @@ guessing.
 
 Some fields are normalized for you. Switching to `text` clears `stt`, `tts`,
 `greeting`, `turn_handling` and `avatar`. Switching to `video` fills in an
-`avatar`, and always has `resume_false_interruption` off — the avatar cannot
-resume a sentence it has already stopped rendering.
+`avatar`, and the call ignores `resume_false_interruption` — the avatar cannot
+resume a sentence it has already stopped rendering. Keypad input is voice-only
+and a text agent cannot watch a screen share, so enabling either off its channel
+is refused: turn it off in the same write that switches the channel.
 
 ### Choosing models
 
@@ -413,7 +446,7 @@ without you doing anything. Rules worth knowing before you hit them:
   `deepgram/nova-3` and both xAI speech-to-text models transcribe as English on
   Auto and will mistranscribe a caller who speaks anything else. For an agent
   taking non-English calls on Auto, pick `deepgram/nova-3-general` (`multi`),
-  `deepgram/flux-general-multi`, `sarvam/saaras:v3` (`unknown`), ElevenLabs
+  `deepgram/flux-general-multi`, `sarvam/saaras:v4` (`unknown`), ElevenLabs
   Scribe or OpenAI — all of which detect for real.
 - Models that publish no languages (OpenAI TTS is multilingual, Deepgram encodes
   the language in the voice) simply ignore the setting.
@@ -823,11 +856,11 @@ before hanging up — logging the outcome, posting a lead — goes **before** th
 Each hook points at a **published tool id**, or null.
 
 - **`on_enter`** — a session opens. It finishes *before* the greeting, which
-  waits for it and reads whatever it published to userdata; on text, when the
-  conversation window opens. A handoff target runs it and then speaks its own
+  waits for it and reads whatever it published to userdata; on text, once, when
+  the chat's first message arrives. A handoff target runs it and then speaks its own
   greeting — or, having none, opens with a generated line instead.
-- **`on_exit`** — the session closes: call end or handoff on voice and video;
-  on text, `end_call`, a closed window, or about a minute idle.
+- **`on_exit`** — the call or chat ends, or this agent hands off. On text it
+  runs once, when the chat ends; what it says is saved to the chat.
 - **`on_user_turn_completed`** — after every user turn, before the LLM replies.
   Each spoken turn on voice and video, each inbound message on text. The user's
   words arrive as `{{args.user_message}}`. On an agent with
@@ -902,8 +935,8 @@ message, draft an opening line, take a shipping address mid-call.
 - **`max_steps`** (default 25, max 50) — how many LLM → tools → LLM **rounds**
   a STANDALONE run may take. A round, not a tool call: four tools in one reply
   cost one step. This is the runaway-loop guard. Entered by an agent the task
-  runs on the calling session's budget instead — three rounds per reply on
-  voice and video, twenty-five on text, refreshed on every user turn.
+  runs on the calling agent's `max_steps` instead, refreshed on every user
+  turn.
 - **`timeout_seconds`** (default 300, max 600) — the real time budget, and the
   one setting that applies both ways. Entered by an agent it is the only bound
   on how long the task may hold the caller: keep it short on a voice agent.
@@ -942,26 +975,27 @@ fields. Never declare a tool of that name yourself.
 
 **Nothing is appended to a task's prompt.** `submit_result_description` is the
 whole of what the model is told about how a run ends, so it has to say that
-calling the tool IS the ending — a written answer produces nothing — and that a
-value the model could not determine goes in as `null`. It is required and
-non-empty, but a new task only carries the one-line stub
-`"Submit the result and finish."`: **replace it.** A task whose finishing is
-described by that stub is a task relying on the model to guess.
-
-Every output field is **required and nullable** in that tool. The model must say
-something about every field, including "I could not find it" — an optional field
-lets it silently omit the address it failed to find, and "omitted" and "not
-generated yet" then look identical to whoever reads the row. Say so in each
-field's `description`: that description is the only instruction the model gets
-about what belongs there.
+calling the tool IS the ending — a written answer produces nothing — and when the
+job is done enough to call it. It is required and
+non-empty; a new task starts with `"Submit results if you are sure that you have achieved the goal of this task"`. **Make it specific**: what
+"achieved" means for this task (e.g. "once the caller has confirmed the address").
+
+Every output field is a **required argument** of that tool — an optional one lets
+the model silently omit the address it failed to find, and "omitted" and "not
+generated yet" then look identical to whoever reads the row. A field's own
+`required` flag (default `true`) decides whether `null` is accepted: turn it off
+for a value the model may legitimately fail to find, and say in that field's
+`description` when to send null — the description is the only instruction the
+model gets about what belongs there.
 
 A task an agent enters also gets **`finish_without_result`**, which abandons the
 job and fails the calling agent's tool call.
 `finish_without_result_description` — required and non-empty too, and starting as
-the stub `"Give up and finish without a result."` — is the only thing saying when
-that is allowed: **a task that gives up on work it should have finished is fixed
-there, not in the prompt.** Narrow it to the caller actually changing their mind;
-"I could not work out a value" is a `null`, not a reason to abandon. Publishing
+`"Finish without result only if you have failed to achieve the goal of this task and would like to give up rather than continue."` — is the only thing saying when that is allowed: **a task that gives up on
+work it should have finished is fixed there, not in the prompt.** Narrow it for the
+task (the caller changing their mind, a named number of failed attempts). Giving up
+IS how a task reports failure, so never add a success/failure boolean to `output`;
+a value it may legitimately not find is a field with `required` off. Publishing
 refuses either description blank.
 
 ### Reading a run
@@ -1041,10 +1075,14 @@ back off the integration, or read `exposed_name` from
 `allowed_tools` still approves the server's own names. Two attached servers
 sharing a namespace fails publish.
 
-**Channel integrations** (Telegram) deploy an agent to a messaging
+**Channel integrations** (Telegram, WhatsApp) deploy an agent to a messaging
 channel through *triggers*, not MCP attachment. A trigger binds an inbound event
 to a published text agent and decides what happens with the reply.
 
+A Twilio WhatsApp number also takes calls: a `whatsapp.call.inbound` trigger puts a
+published **voice** agent on it, which must use `conversation.context: "transcript"` —
+the call joins the chat's thread. It cannot transfer to a phone number.
+
 `integration_catalog` is the authoritative list of providers and, in
 `setup_fields`, exactly what each one needs — read it instead of guessing.
 Providers whose `auth_type` is `oauth` must be connected from the dashboard's
@@ -1055,7 +1093,7 @@ stores it as a workspace secret and wires the reference, or pass an existing
 
 ## Phone numbers
 
-A voice or video agent answers the phone once a number is pointed at it. Three
+A voice agent answers the phone once a number is pointed at it. Three
 things have to line up, in order:
 
 1. **A carrier account** — the credential for a phone network.
@@ -1068,8 +1106,10 @@ things have to line up, in order:
    provisions them. Numbers are bought at the carrier, never here. Import
    reports per number: read every `ok` rather than trusting the 200.
 3. **An agent on the number** — `assign_phone_number` puts a **published**
-   voice or video agent on it. Republishing the agent updates live calls
-   automatically; the assignment is not redone.
+   `voice` agent on it. Republishing the agent updates live calls
+   automatically; the assignment is not redone. A publish or rollback that
+   would take it off `voice` is refused while any number, stream connection or
+   running batch uses it.
 
 `readiness` on a number is the honest answer to "does this work": `live`,
 `needs_agent`, `needs_carrier_setup`, `setting_up`, `error` or `disabled`.
@@ -1110,8 +1150,9 @@ window may cross midnight; the days then name the evening it starts on.
 **Say these two things before creating one**, because a user who discovers
 either from an invoice will not forgive us:
 
-- **Answering machines are not detected.** A call that reaches voicemail is
-  answered, billed, and reported as completed.
+- **Voicemail is answered and billed** unless the agent has
+  `voicemail_detection` on — then it hangs up (after its message, if it has one),
+  the call ends as `voicemail`, and the recipient is retried like a missed call.
 - **Every call runs the agent's current published version**, so republishing
   mid-batch changes every call placed after that moment.
 
@@ -1271,10 +1312,36 @@ the review table as drafts and never takes the batch with it; the drafts are
 still there. In the other direction, pausing or cancelling the *batch* stops
 drafting and does not touch a send that is already scheduled or going out.
 
+## WhatsApp outbound
+
+A **WhatsApp batch** sends one *approved* template to every row of a CSV from a
+connected WhatsApp integration. There is no drafting: Meta approved the wording,
+and only the template's variables change per row. `list_whatsapp_templates`
+gives a sender's approved templates — header, body, footer, buttons and variable
+names; one with `unsupported_reason` cannot be used.
+`create_whatsapp_batch` maps `to_column` and every variable onto CSV columns. A
+row with a bad or repeated phone, or a blank mapped cell, is kept and skipped
+with the reason, so read the returned `counts`.
+
+**Say these before creating one:**
+
+- **Only people who opted in to hear from the business on WhatsApp** may be
+  messaged. Cold outreach breaks WhatsApp's policy and risks their number.
+- **US numbers never receive marketing templates**, and Meta caps the marketing
+  templates any one person receives.
+- **You cannot send it.** `send_whatsapp_batch` and `resume_whatsapp_batch` are
+  a person's to press, on the batch page. Create the batch, point them at it.
+
+Replies are answered by the agent on the sender's
+`whatsapp.message.inbound` trigger, which sees the row's columns as
+`{{userdata.<column>}}` and the whole template, buttons included, as its own
+first message — so write that agent's prompt against the CSV's column names.
+
 ## Knowledge bases
 
 A knowledge base gives an agent grounded answers over crawled content. Attach
-ready ones through the agent's `kb_ids`; only `ready` ones can be attached.
+it through the agent's `kb_ids`. A call reads only `ready` ones, so one still
+building can be attached now and is used once it finishes.
 
 Building one runs in three stages and takes minutes, not seconds:
 
@@ -1320,8 +1387,8 @@ Published agents can be run from here, and every run leaves a record.
 
 **Starting something.** `create_outbound_call` dials a real phone number from
 one of the workspace's numbers and puts a published voice agent on the call.
-`create_text_conversation` plus `create_text_message` talks to a published text
-agent — the fastest way to try one. `calls_token` mints the token a *browser*
+`create_chat` plus `create_chat_message` talks to a published text agent — the
+fastest way to try one. `calls_token` mints the token a *browser*
 needs to join a web call; it starts nothing by itself.
 
 All three take `userdata`, which seeds the session's state and is readable as
@@ -1337,8 +1404,7 @@ for facts about the person and `vars` for configuration of the session; unlike
 can change it mid-session. An empty string is a deliberate blank, not a request
 for the default. The model can see the values, so credentials stay in workspace
 secrets. On a batch it is one bag for the whole campaign, copied onto every call
-it places — per-person data is what a recipient's `userdata` is for. On a text
-conversation it is fixed for the life of the thread.
+it places — per-person data is what a recipient's `userdata` is for.
 
 **Per-call configuration.** All three — and `create_call_batch` — also take four
 fields that change what runs on that one call:
@@ -1371,12 +1437,14 @@ The merged result is validated by the same rules that guard publishing, so a
 bad override is a 400 at create — naming the problem — rather than a call that
 connects and then fails.
 
-`create_text_message` returns as soon as the message is accepted — the agent
-replies asynchronously, so poll `list_conversation_items` (with `order: desc`)
-for the reply. Give it a few seconds, and expect several items when the agent
-calls tools.
+A chat is one text session, as a call is a voice one. `create_chat_message`
+takes a `client_message_id` (a UUID you generate) and returns the reply itself:
+`status`, `items` and `chat_status`. A chat **ends only explicitly** — the
+agent's `end_call`, or `end_chat` — and only then is it analysed and its
+`session.completed` sent, so end the chats you start. On Telegram and WhatsApp a
+person's messages join one chat until it ends; the next starts a new one.
 
-It can also carry `images`: up to four `{data_url, filename}` entries beside
+A message can carry `images`: up to four `{data_url, filename}` entries beside
 `message`, each a base64 `data:image/...` URL of a JPEG, PNG or WebP under 10 MB.
 The caption and the photo arrive as one turn and one item, so send them together
 rather than as two messages. The agent's model must have `vision` (see *Images*
@@ -1384,17 +1452,16 @@ above) or the call is refused naming the model.
 
 **Reading it back.** A *conversation* is the thread with a person, on any
 surface; a *call* is one voice or video session. `list_conversations` and
-`list_conversation_items` are the transcript; `list_conversation_sessions` says
-which agent version handled each turn of it. `list_calls` and `get_call` cover
-phone and web calls — `get_call` gives the transcript with every tool call and
+`list_conversation_items` are the transcript; `list_conversation_sessions` lists
+its calls and chats, and `get_chat` gives one chat's cost and analysis.
+`list_calls` and `get_call` cover phone and web calls — `get_call` gives the transcript with every tool call and
 its output, plus usage, cost and a per-stage latency breakdown, which is where
 you find out why an agent did something odd or answered slowly.
 `get_observability` is the workspace view: sessions, spend and latency per day.
 
 What a run costs is the provider spend on the workspace's own keys plus
-Talqing's per-minute platform fee, which `get_catalog` gives per channel. **Text
-agents carry no platform fee at all** — a text conversation costs the workspace
-only what its own LLM key was charged.
+Talqing's platform fee, which `get_catalog` gives: per minute on voice and
+video, and $0.0001 per answered message on text.
 
 When an agent misbehaves, read the actual run before theorizing. The transcript
 and the final `userdata` usually name the cause.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talqing/mcp",
-  "version": "0.3.4",
+  "version": "0.5.0",
   "description": "MCP server for building Talqing AI voice, video and text agents from Claude Code, Codex, or any MCP client.",
   "license": "MIT",
   "homepage": "https://talqing.com",

package/tools.json

@@ -59,7 +59,7 @@
       "role": "write"
     },
     {
-      "description": "Delete an agent and its published versions permanently.",
+      "description": "Delete an agent and its versions permanently; 409 while anything still points at it.",
       "method": "DELETE",
       "name": "delete_agent",
       "parameters": {
@@ -84,7 +84,7 @@
       },
       "path": "/v1/agents/{agent_id}/validate",
       "read_only": false,
-      "role": "write"
+      "role": "read"
     },
     {
       "description": "Freeze the current draft as a new immutable version and make it live.",
@@ -210,7 +210,7 @@
       },
       "path": "/v1/tools/{tool_id}/validate",
       "read_only": false,
-      "role": "write"
+      "role": "read"
     },
     {
       "description": "Run the draft tool once with arguments you supply and see every step.",
@@ -350,7 +350,7 @@
       },
       "path": "/v1/tasks/{task_id}/validate",
       "read_only": false,
-      "role": "write"
+      "role": "read"
     },
     {
       "description": "Freeze the current draft as a new immutable version and make it live.",
@@ -1151,7 +1151,7 @@
       "role": "write"
     },
     {
-      "description": "Stop a batch for good. There is no undo, and a batch cannot be deleted.",
+      "description": "Stop a batch for good. There is no undo.",
       "method": "POST",
       "name": "cancel_call_batch",
       "parameters": {
@@ -1263,7 +1263,7 @@
       "role": "write"
     },
     {
-      "description": "Stop drafting for good. A batch cannot be deleted, because it is the record of what was sent to whom.",
+      "description": "Stop drafting for good.",
       "method": "POST",
       "name": "cancel_email_batch",
       "parameters": {
@@ -1444,6 +1444,160 @@
       "read_only": false,
       "role": "write"
     },
+    {
+      "description": "List a WhatsApp sender's approved templates, read live from its BSP.",
+      "method": "GET",
+      "name": "list_whatsapp_templates",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('list_whatsapp_templates').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/whatsapp/templates",
+      "read_only": true,
+      "role": "read"
+    },
+    {
+      "description": "Create a WhatsApp batch: one approved template, sent once per CSV row. Sends nothing yet.",
+      "method": "POST",
+      "name": "create_whatsapp_batch",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('create_whatsapp_batch').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/whatsapp/batches",
+      "read_only": false,
+      "role": "write"
+    },
+    {
+      "description": "List WhatsApp batches, newest first.",
+      "method": "GET",
+      "name": "list_whatsapp_batches",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('list_whatsapp_batches').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/whatsapp/batches",
+      "read_only": true,
+      "role": "read"
+    },
+    {
+      "description": "One batch: its template, schedule and per-status counts, `replied` included.",
+      "method": "GET",
+      "name": "get_whatsapp_batch",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('get_whatsapp_batch').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/whatsapp/batches/{batch_id}",
+      "read_only": true,
+      "role": "read"
+    },
+    {
+      "description": "Edit a batch. Pacing and the window reach a live send within minutes.",
+      "method": "PATCH",
+      "name": "patch_whatsapp_batch",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('patch_whatsapp_batch').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/whatsapp/batches/{batch_id}",
+      "read_only": false,
+      "role": "write"
+    },
+    {
+      "description": "Stop sending before the next message. Nothing is lost.",
+      "method": "POST",
+      "name": "pause_whatsapp_batch",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('pause_whatsapp_batch').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/whatsapp/batches/{batch_id}/pause",
+      "read_only": false,
+      "role": "write"
+    },
+    {
+      "description": "Stop for good. Messages already sent stay sent, and replies are still answered.",
+      "method": "POST",
+      "name": "cancel_whatsapp_batch",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('cancel_whatsapp_batch').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/whatsapp/batches/{batch_id}/cancel",
+      "read_only": false,
+      "role": "write"
+    },
+    {
+      "description": "A batch's rows in upload order, each with its rendered message.",
+      "method": "GET",
+      "name": "list_whatsapp_batch_recipients",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('list_whatsapp_batch_recipients').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/whatsapp/batches/{batch_id}/recipients",
+      "read_only": true,
+      "role": "read"
+    },
+    {
+      "description": "Edit cells on a row not yet sent, its phone included. An empty value clears the edit.",
+      "method": "PATCH",
+      "name": "patch_whatsapp_batch_recipient",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('patch_whatsapp_batch_recipient').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/whatsapp/batches/{batch_id}/recipients/{recipient_id}",
+      "read_only": false,
+      "role": "write"
+    },
+    {
+      "description": "Take ready rows out of the send. Reversible with restore.",
+      "method": "POST",
+      "name": "skip_whatsapp_batch_recipients",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('skip_whatsapp_batch_recipients').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/whatsapp/batches/{batch_id}/recipients/skip",
+      "read_only": false,
+      "role": "write"
+    },
+    {
+      "description": "Put rows a person skipped back. A row skipped for its cells returns when they are fixed.",
+      "method": "POST",
+      "name": "restore_whatsapp_batch_recipients",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('restore_whatsapp_batch_recipients').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/whatsapp/batches/{batch_id}/recipients/restore",
+      "read_only": false,
+      "role": "write"
+    },
     {
       "description": "Mint a LiveKit token for a browser to open a web call with an agent.",
       "method": "POST",
@@ -1459,30 +1613,128 @@
       "role": "write"
     },
     {
-      "description": "Open a text conversation with a published text agent.",
+      "description": "Start a chat with a text agent. Send it messages with `create_chat_message`.",
       "method": "POST",
-      "name": "create_text_conversation",
+      "name": "create_chat",
       "parameters": {
         "additionalProperties": true,
-        "description": "Arguments not inlined: call describe_function('create_text_conversation').",
+        "description": "Arguments not inlined: call describe_function('create_chat').",
         "properties": {},
         "type": "object"
       },
-      "path": "/v1/conversations",
+      "path": "/v1/chats",
+      "read_only": false,
+      "role": "write"
+    },
+    {
+      "description": "List chats, newest first.",
+      "method": "GET",
+      "name": "list_chats",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('list_chats').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/chats",
+      "read_only": true,
+      "role": "read"
+    },
+    {
+      "description": "Read one chat: its status, cost so far and, once ended, its analysis.",
+      "method": "GET",
+      "name": "get_chat",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('get_chat').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/chats/{chat_id}",
+      "read_only": true,
+      "role": "read"
+    },
+    {
+      "description": "One chat with its health snapshot, cost lines, vars and event trace.",
+      "method": "GET",
+      "name": "get_chat_detail",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('get_chat_detail').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/chats/{chat_id}/detail",
+      "read_only": true,
+      "role": "read"
+    },
+    {
+      "description": "Analyse an ended chat again with its agent's saved definition.",
+      "method": "POST",
+      "name": "rerun_chat_analysis",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('rerun_chat_analysis').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/chats/{chat_id}/analysis",
+      "read_only": false,
+      "role": "write"
+    },
+    {
+      "description": "Try an analysis definition against an ended chat. Nothing is saved; costs one model call.",
+      "method": "POST",
+      "name": "preview_chat_analysis",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('preview_chat_analysis').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/chats/{chat_id}/analysis/preview",
+      "read_only": false,
+      "role": "write"
+    },
+    {
+      "description": "The messages, tool calls and handoffs of one chat.",
+      "method": "GET",
+      "name": "list_chat_items",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('list_chat_items').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/chats/{chat_id}/items",
+      "read_only": true,
+      "role": "read"
+    },
+    {
+      "description": "Send a message and get the agent's reply back on this request.",
+      "method": "POST",
+      "name": "create_chat_message",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('create_chat_message').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/chats/{chat_id}/messages",
       "read_only": false,
       "role": "write"
     },
     {
-      "description": "Send a message to a text agent \u2014 the way to actually talk to one.",
+      "description": "End a chat. Its analysis and `session.completed` webhook follow.",
       "method": "POST",
-      "name": "create_text_message",
+      "name": "end_chat",
       "parameters": {
         "additionalProperties": true,
-        "description": "Arguments not inlined: call describe_function('create_text_message').",
+        "description": "Arguments not inlined: call describe_function('end_chat').",
         "properties": {},
         "type": "object"
       },
-      "path": "/v1/conversations/messages",
+      "path": "/v1/chats/{chat_id}/end",
       "read_only": false,
       "role": "write"
     },
@@ -1683,7 +1935,7 @@
       "role": "admin"
     },
     {
-      "description": "Delete a secret permanently. Anything still referencing it will fail to resolve at runtime. Organization admins only.",
+      "description": "Delete a secret permanently. Refused with 409 while a tool, integration or carrier account references it. Organization admins only.",
       "method": "DELETE",
       "name": "delete_secret",
       "parameters": {