@talqing/mcp 0.8.1 → 0.9.1

package/README.md

@@ -145,7 +145,7 @@ cannot drift from the product:
 PYTHONPATH=backend python openapi/export.py
 ```
 
-`tools.json` comes from `backend/api/dataplane/operations.py`, the same registry
+`tools.json` comes from `backend/api/functions.py`, the same registry
 the CoPilot binds its tools from; `SKILL.md` comes from
 `backend/services/copilot/skill.md`, the same text the CoPilot is prompted with.
 Edit those, re-run the export, and both surfaces move together.

package/SKILL.md

@@ -200,10 +200,10 @@ An agent is a single object, `config`, plus what you attach to it:
 - **`handoffs`** — where this agent may pass the conversation next, each
   `{"name": "Billing", "agent_id": "...", "description": "...", "context":
   "transcript" | "summary" | "none", "recent_turns": 2, "summary_prompt": "...",
-  "message": "..."}`. The compiler turns each entry into one tool the model can
-  call, `handoff_to_<name>`, and the model routes on `description` — so write
-  that as what belongs there ("invoices, refunds, payment questions"), not as an
-  instruction.
+  "message": "...", "instructions": "..."}`. The compiler turns each entry into
+  one tool the model can call, `handoff_to_<name>`, and the model routes on
+  `description` — so write that as what belongs there ("invoices, refunds,
+  payment questions"), not as an instruction.
 
   **This is how you build a multi-agent flow.** Do not create a one-node tool
   per edge: three agents routing to each other is three agents with `handoffs`
@@ -220,31 +220,34 @@ An agent is a single object, `config`, plus what you attach to it:
   instructions once a call is connected, so an agent with both that realtime
   model and a handoff destination is refused on save. Every other model is fine.
 
-  **`context` is what the next agent starts from** — the same three words an
-  agent's own `conversation.context` uses for what a new *call* starts from.
+  **`context` is what the next agent inherits from THIS agent's own context** —
+  the same three words an agent's own `conversation.context` uses, answering a
+  different question (that one is what a new session starts with, and is read
+  only from the agent that answers).
 
-  - `transcript` (the default) hands over everything said so far. Nothing to
-    configure, and the target pays for all of it on every turn it then takes.
+  - `transcript` (the default) hands over exactly what this agent knows, minus
+    its own instructions. Nothing to configure, and the target pays for all of
+    it on every turn it then takes.
   - `summary` asks THIS agent to write the summary itself, as an argument on the
     `handoff_to_*` tool, in the same turn as the decision to hand over. There is
     no second LLM call, so a realtime agent can use it too. It costs a pause
     before the handoff — the agent writes 60–100 tokens before the tool returns
     — and buys a short, focused context that the source agent chose, instead of
     forty turns the target has to re-read every turn.
-  - `none` starts the target with only its own instructions.
+  - `none` starts the target with only its own instructions — nothing about the
+    conversation, and nothing a later `transcript` edge can recover either.
 
-  **`recent_turns`** (1–10) is how many recent turns cross *verbatim* alongside
-  the summary, so the target knows what is being asked right now. A turn starts
+  **`recent_turns`** (1–10, `summary` only) is how many recent turns of THIS
+  session cross *verbatim* alongside the summary, so the target knows what is
+  being asked right now. A turn starts
   at a user message and runs until the next one, so a turn that took a tool call
   and two replies crosses whole. Tool calls themselves never cross — their
   results are knowledge, and knowledge belongs in the summary.
 
-  Leave it out and each policy answers for itself: `summary` carries two turns,
-  and `none` carries none. Under `summary` the tail can be sized down to one turn
-  but **not** switched off — a summary with no tail leaves the target knowing the
-  history and not the question. Under `none` it is opt-in, and `{"context":
-  "none", "recent_turns": 3}` is a real and useful combination: the last three
-  turns and nothing else. Past ten turns the honest answer is `transcript`.
+  Leave it out and it is two. It can be sized down to one turn but **not**
+  switched off — a summary with no tail leaves the target knowing the history
+  and not the question. If the summary comes back blank the target gets the tail
+  alone. Past ten turns the honest answer is `transcript`.
 
   **`summary_prompt`** replaces the platform's default line with your own. It is
   the *description of the tool argument*, so it is literally what the agent is
@@ -253,9 +256,15 @@ An agent is a single object, `config`, plus what you attach to it:
   naming three buckets — what the caller wants, what has been done, what is still
   open — and a longer one buys a longer pause before the handoff.
 
+  **`instructions`** is what the target is told as it opens, passed to its first
+  `generate_reply` — e.g. "Don't introduce yourself; answer the caller's last
+  question." Used only when the target has no greeting (text targets never have
+  one). Leave it out and the target is told nothing: it opens from its own prompt
+  and the context it was handed, so put standing behaviour like "never
+  re-introduce yourself" in the target's prompt instead.
+
   `recent_turns` and `summary_prompt` are **rejected** where they do not apply,
-  rather than ignored: no `recent_turns` under `transcript`, which already
-  carries every turn, and no `summary_prompt` outside `summary`.
+  rather than ignored: neither outside `summary`.
 
   **`summary` is not a privacy boundary, and must not be described as one.** It
   narrows what the target model is shown; it guarantees nothing. The tail always
@@ -437,13 +446,13 @@ without you doing anything. Rules worth knowing before you hit them:
   English does not come back transliterated, it comes back with words missing, and
   the agent never learns it misheard.
 - **Auto does not mean "detects" everywhere.** A model with a `default_language`
-  runs on that code when the agent is on Auto, and the ones spelled `unknown`,
+  runs on that code when the agent is on Auto, and the ones spelled
   `multi` or `auto` are the providers' own words for detection. The rest are
   real languages, and English is what a model that cannot detect falls back to:
   `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:v4` (`unknown`), ElevenLabs
+  `deepgram/flux-general-multi`, `sarvam/saaras:v4` (`auto`), 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.
@@ -715,6 +724,10 @@ instead.
 - **`say`** — spoken verbatim.
 - **`generate_reply`** — the LLM writes the reply.
 - **`add_message`** — adds a system message without triggering a reply.
+  `scope: "conversation"` (default) keeps it for the rest of the conversation;
+  `scope: "turn"` gives it to the model for this one reply only — allowed only
+  in the `on_user_turn_completed` hook, and the right choice there for per-turn
+  lookups, which would otherwise pile up a message every turn.
 - **`end_call`** — put a `say` immediately before it if there should be a
   goodbye, and word that goodbye as what actually happens: the call ends here.
   Never say "let me transfer you", "please hold" or "someone will call you
@@ -738,8 +751,9 @@ instead.
   under any other context is an error.
 
   `recent_turns` works exactly as it does on `handoffs[]`: the tail that
-  crosses verbatim, defaulting to two turns under `summary` and to none under
-  `none`, and rejected under `transcript`.
+  crosses verbatim beside the summary, defaulting to two, and rejected under any
+  other context. `instructions` is the same as on
+  `handoffs[]`, and is a template.
 
   Reach for this operation only when the decision is the TREE's — after an
   `http` lookup, inside an `if`. When the model should decide which desk the
@@ -1106,8 +1120,8 @@ 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.
+published **voice** agent on it. The call always joins the chat's thread, whatever
+the agent's `conversation.context` says. 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talqing/mcp",
-  "version": "0.8.1",
+  "version": "0.9.1",
   "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

@@ -1584,6 +1584,20 @@
       "read_only": false,
       "role": "write"
     },
+    {
+      "description": "Mint a token for a new web call that continues one that ended.",
+      "method": "POST",
+      "name": "resume_call",
+      "parameters": {
+        "additionalProperties": true,
+        "description": "Arguments not inlined: call describe_function('resume_call').",
+        "properties": {},
+        "type": "object"
+      },
+      "path": "/v1/calls/{session_id}/resume",
+      "read_only": false,
+      "role": "write"
+    },
     {
       "description": "Start a chat with a text agent. Send it messages with `create_chat_message`.",
       "method": "POST",