tavus-cli 0.10.2__tar.gz → 0.10.4__tar.gz

tavus_cli-0.10.4/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.10.4"
+}

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.10.4](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.10.3...v0.10.4) (2026-10-19)
+
+
+### Bug Fixes
+
+* support PAL meeting setup, dispatch, and all verification probes ([#80](https://github.com/Tavus-Engineering/tavus-mcp/issues/80)) ([c635462](https://github.com/Tavus-Engineering/tavus-mcp/commit/c635462493098269f3361c2f0ff2d2fc3869bece))
+
+## [0.10.3](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.10.2...v0.10.3) (2026-10-16)
+
+
+### Bug Fixes
+
+* preserve every received Builder reply in MCP history ([#78](https://github.com/Tavus-Engineering/tavus-mcp/issues/78)) ([7dab660](https://github.com/Tavus-Engineering/tavus-mcp/commit/7dab660ddaa3110f208f343e90981217c10cdb20))
+
 ## [0.10.2](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.10.1...v0.10.2) (2026-10-16)
 
 

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tavus-cli
-Version: 0.10.2
+Version: 0.10.4
 Summary: Tavus CLI and MCP server for agentic PAL creation and editing.
 Requires-Python: >=3.11
 Requires-Dist: fastmcp>=2.0.0

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/packages/tavus/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "tavus"
-version = "0.10.2" # x-release-please-version
+version = "0.10.4" # x-release-please-version
 description = "Official alias for tavus-cli, the Tavus CLI and MCP server."
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
-  "tavus-cli==0.10.2", # x-release-please-version
+  "tavus-cli==0.10.4", # x-release-please-version
 ]
 
 [project.urls]

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/packages/tavus-mcp/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "tavus-mcp"
-version = "0.10.2" # x-release-please-version
+version = "0.10.4" # x-release-please-version
 description = "Official alias for tavus-cli, which provides the tavus-mcp MCP server."
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
-  "tavus-cli==0.10.2", # x-release-please-version
+  "tavus-cli==0.10.4", # x-release-please-version
 ]
 
 [project.urls]

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tavus-cli"
-version = "0.10.2"
+version = "0.10.4"
 description = "Tavus CLI and MCP server for agentic PAL creation and editing."
 readme = "README.md"
 requires-python = ">=3.11"

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/skills/tavus-agentic-pals/SKILL.md

@@ -136,7 +136,7 @@ Knowledge document tools:
 Conversation and resource tools:
 
 - `tavus_face_list(limit, stock)`
-- `tavus_conversation_create(pal_id, face_id, conversation_name)`
+- `tavus_conversation_create(pal_id?, face_id?, conversation_name?, meeting_url?)`
 - `tavus_conversation_end(conversation_id)`
 - `tavus_quickstart(system_prompt, pal_name, face_id)`
 - `tavus_resource_list(resource, limit)` for `guardrails`, `objectives`, `documents`, `voices`, `skills`, or `tools`
@@ -279,6 +279,20 @@ Prefer focused patches over full rebuilds:
 
 Common patch targets include `/system_prompt`, `/greeting`, `/context`, `/pal_name`, `/default_face_id`, `/objectives_id`, `/guardrail_ids`, `/guardrail_tags`, `/document_ids`, `/document_tags`, and nested layer paths under `/layers/llm`, `/layers/tts`, `/layers/stt`, `/layers/perception`, `/layers/conversational_flow`, `/layers/capabilities`, and `/layers/knowledge_base`.
 
+For meeting participation, set `wake_phrase` and `sleep_phrase` under
+`/layers/conversational_flow`. Save both phrases together; a sleep phrase
+requires a wake phrase. Configure `/layers/conferencing` in a separate patch
+with `username`, `allowlist`, and `whitelabel`. The API rejects a patch that
+mixes conferencing with behavior settings. A default face must be selected
+before claiming a conferencing identity. Read back `layers.conferencing.email`
+for the invite address; do not construct it yourself. Before joining a meeting,
+ask the creator for its link and confirm that the PAL is expected there.
+Creating a conferencing identity does not join a call. Test waking and sleeping
+in a real voice call before claiming the meeting behavior works.
+To send the PAL to the supplied meeting link, call `tavus_conversation_create`
+with `pal_id` and `meeting_url`. A successful response confirms dispatch, not
+admission. Check the meeting participant list before saying the PAL joined.
+
 ## Creation Patterns
 
 Use `tavus_quickstart` or `uv run tavus quickstart` when the user wants a pal plus a conversation quickly. It uses the first stock face unless a face ID is provided.

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/skills/tavus-agentic-pals/references/build-and-verify.md

@@ -47,6 +47,10 @@ tavus_pal_build_and_verify(
 )
 ```
 
+The hosted connector accepts up to five supplied probes and retains all of
+them. Generated probes are capped at three. The smoke test has a shared time
+budget; a probe that cannot run is reported in the transcript with an error.
+
 ### Changing an existing PAL (hosted connector)
 
 Pass `pal_id` to run the same drafters on an existing PAL. Put the requested

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/skills/tavus-agentic-pals/references/chat-mode.md

@@ -88,6 +88,24 @@ timeout covers the join, but budget the first `collect_turn` generously.
 Always `close()` the session and end the conversation in `finally:` —
 orphaned chat sessions still consume quota.
 
+## Conversation history
+
+Reuse the returned `conversation_id` for each turn of the same test. CVI owns
+that conversation's user and assistant history; starting another conversation
+does not restore the previous test. In chat mode, CVI must commit each reply
+before delivering it, without waiting for audio playback. The MCP client does
+not replay earlier turns into the prompt. If a PAL repeats answered questions,
+check that its delivered replies appear in the next CVI model input; seeing
+them in the tool result alone does not prove they were retained.
+
+Builder history is separate. `tavus_pal_builder_history` reads the creator's
+saved dialogue with Charlie, not the PAL's test conversation. The local
+Builder recipe saves each received reply before executing tools or requesting
+a continuation, so a later timeout does not erase earlier dialogue. Automatic
+drafting instructions and test/refinement prompts are not saved as creator
+messages. A resumed Builder receives a bounded snapshot from request-handler;
+the full saved dialogue remains available through the history tools.
+
 For fully offline unit tests, monkeypatch
 `daily_transport.open_conversation_session` with a scripted fake session (see
 `tests/unit/test_build_and_verify.py::FakeSession`).

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/src/tavus_mcp/__init__.py

@@ -1,4 +1,4 @@
 """Tavus CLI and MCP server package."""
 
 __all__ = ["__version__"]
-__version__ = "0.10.2"  # x-release-please-version
+__version__ = "0.10.4"  # x-release-please-version

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/src/tavus_mcp/sdk/recipes/build_and_verify.py

@@ -114,6 +114,8 @@ async def build_and_verify(
             answer_provider=None,
             on_builder_reply=None,
             transcript=build_transcript,
+            record_creator_prompt=False,
+            creator_request=prompt,
         )
         await client.builders.publish(builder_id)
         spec = await _assemble_spec(client, pal_id)

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/src/tavus_mcp/sdk/recipes/carrier_builder.py

@@ -95,15 +95,19 @@ async def run_carrier_build(
     answer_provider: AnswerProvider | None,
     on_builder_reply: BuildProgress | None,
     transcript: list[dict[str, Any]],
+    record_creator_prompt: bool = True,
+    creator_request: str | None = None,
 ) -> str:
     """Build or refine one PAL through a real, headless Charlie conversation."""
+    initial_request = creator_request if creator_request is not None else prompt
     runtime: dict[str, Any] = {
         "pal_id": pal_id,
         "builder_id": builder_id,
         "read_documents": {},
         "drafted": False,
+        "creator_request": initial_request,
     }
-    initial_context = await build_carrier_context(client, runtime, initial_request=prompt)
+    initial_context = await build_carrier_context(client, runtime, initial_request=initial_request)
     created = await client.conversations.create_headless_builder(
         {
             "builder_id": builder_id,
@@ -134,6 +138,7 @@ async def run_carrier_build(
     human_driven = answer_provider is not None or answers is not None
     answer_index = 0
     next_message = _complete_brief(prompt) if not human_driven else prompt
+    creator_message = prompt if record_creator_prompt else None
     max_creator_turns = max_rounds + 1 if human_driven else max_rounds
 
     try:
@@ -157,7 +162,8 @@ async def run_carrier_build(
                 client,
                 runtime,
                 next_message,
-                initial_request=prompt,
+                creator_message=creator_message,
+                initial_request=initial_request,
                 transcript=transcript,
             )
             if on_builder_reply is not None:
@@ -176,6 +182,7 @@ async def run_carrier_build(
                     answer_index += 1
                 else:
                     break
+                creator_message = next_message
                 continue
 
             if runtime["drafted"]:
@@ -185,6 +192,7 @@ async def run_carrier_build(
                 "Do not ask me another setup question: name the PAL and dispatch "
                 "a complete first draft now."
             )
+            creator_message = None
 
         if not runtime["drafted"]:
             await _run_creator_turn(
@@ -192,7 +200,8 @@ async def run_carrier_build(
                 runtime,
                 "The build must complete now. Infer any remaining choices from the "
                 "original brief and call draft_pal for a complete first draft.",
-                initial_request=prompt,
+                creator_message=None,
+                initial_request=initial_request,
                 transcript=transcript,
             )
         if not runtime["drafted"]:
@@ -221,27 +230,43 @@ async def _run_creator_turn(
     runtime: dict[str, Any],
     message: str,
     *,
+    creator_message: str | None,
     initial_request: str,
     transcript: list[dict[str, Any]],
 ) -> dict[str, Any]:
     builder_id = str(runtime["builder_id"])
     session = runtime["session"]
-    transcript.append({"role": "user", "text": message})
-    await client.builders.append_messages(
-        builder_id, [{"role": "user", "content": message}]
-    )
+    if creator_message:
+        runtime["creator_request"] = creator_message
+        await client.builders.append_messages(
+            builder_id, [{"role": "user", "content": creator_message}]
+        )
+        transcript.append({"role": "user", "text": creator_message})
 
     reply = await _send_and_collect(session, message)
     tool_names: list[str] = []
-    for _ in range(MAX_TOOL_HOPS):
+    reply_texts: list[str] = []
+    for hop in range(MAX_TOOL_HOPS + 1):
+        text = str(reply.get("text") or "").strip()
+        if text:
+            # Save before tool work or another inference can fail and lose this reply.
+            await client.builders.append_messages(
+                builder_id, [{"role": "assistant", "content": text}]
+            )
+            transcript.append({"role": "assistant", "text": text})
+            reply_texts.append(text)
         calls = list(reply.pop("tool_calls", []))
-        if not calls:
+        if not calls or hop == MAX_TOOL_HOPS:
             break
         outcomes: list[str] = []
         for call in calls:
             name = str(call.get("name") or "")
             tool_names.append(name)
-            outcome = await _execute_carrier_tool(client, runtime, call, message)
+            # RQH persists the drafting message too. Keep transport instructions
+            # and automated nudges out of the creator's saved dialogue.
+            outcome = await _execute_carrier_tool(
+                client, runtime, call, str(runtime["creator_request"])
+            )
             outcomes.append(outcome)
             tool_call_id = str(call.get("tool_call_id") or "")
             if tool_call_id:
@@ -270,21 +295,13 @@ async def _run_creator_turn(
         )
         reply = await _send_and_collect(session, followup)
 
-    text = str(reply.get("text") or "").strip()
-    if not text:
-        text = _tool_narration(reply, tool_names)
     structured_reply = {
-        "text": text,
+        "text": "\n\n".join(reply_texts) or _tool_narration(reply, tool_names),
         "tool_names": tool_names,
         "draft_ready": bool(runtime["drafted"]),
         "targets": [],
         "suggestions": [],
     }
-    transcript.append({"role": "assistant", **structured_reply})
-    if text:
-        await client.builders.append_messages(
-            builder_id, [{"role": "assistant", "content": text}]
-        )
     return structured_reply
 
 

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/src/tavus_mcp/sdk/schemas/pal.py

@@ -74,9 +74,18 @@ class ConversationalFlowLayerPatchModel(BaseModel):
     voice_isolation: str | None = None
     noise_cancellation: str | None = None
     wake_phrase: str | None = None
+    sleep_phrase: str | None = None
     idle_engagement: str | None = None
 
 
+class ConferencingLayerPatchModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    username: str | None = None
+    allowlist: list[str] | None = None
+    whitelabel: bool | None = None
+
+
 class CapabilitiesLayerPatchModel(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
@@ -106,6 +115,7 @@ class LayersPatchModel(BaseModel):
     transport: dict[str, Any] | None = None
     perception: PerceptionLayerPatchModel | None = None
     conversational_flow: ConversationalFlowLayerPatchModel | None = None
+    conferencing: ConferencingLayerPatchModel | None = None
     capabilities: CapabilitiesLayerPatchModel | None = None
     knowledge_base: KnowledgeBaseLayerPatchModel | None = None
 

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/src/tavus_mcp/server.py

@@ -427,7 +427,12 @@ async def tavus_patch_pal(pal_id: str, ops: list[dict[str, Any]]) -> Any:
 
     Tools are first-class now: prefer tavus_tool_create + tavus_pal_tools_attach
     over writing tools inline here. Inline layer tool paths are rejected by the
-    patch validator."""
+    patch validator. Set wake_phrase and sleep_phrase under
+    /layers/conversational_flow. Patch /layers/conferencing separately from
+    behavior settings; it accepts username, allowlist, and whitelabel.
+    Configuring an identity does not join a call. Ask the creator for the
+    meeting link before joining.
+    """
     async with TavusClient.from_env(surface="mcp") as client:
         return await client.pals.patch(pal_id, ops)
 
@@ -853,13 +858,21 @@ async def tavus_conversation_create(
     pal_id: str | None = None,
     face_id: str | None = None,
     conversation_name: str | None = None,
+    meeting_url: str | None = None,
 ) -> Any:
+    """Create a conversation, or send a PAL to an existing meeting.
+
+    Ask the creator for the meeting link before setting meeting_url. The PAL
+    needs a conferencing identity and a default face. Creation confirms the
+    request was sent; verify admission in the meeting before reporting joined.
+    """
     # /v2/conversations is not part of the pal/face alias, so the body keeps the
     # underlying persona_id/replica_id wire fields (id values are identical).
     body = {
         "persona_id": pal_id,
         "replica_id": face_id,
         "conversation_name": conversation_name,
+        "meeting_url": meeting_url,
     }
     async with TavusClient.from_env(surface="mcp") as client:
         return await client.conversations.create({k: v for k, v in body.items() if v})

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/tests/integration/test_mcp_server.py

@@ -23,6 +23,27 @@ from tavus_mcp.server import (
 )
 
 
+@pytest.mark.asyncio
+@respx.mock
+async def test_mcp_dispatches_pal_to_requested_meeting(clean_env: Path) -> None:
+    (clean_env / ".env").write_text(
+        "TAVUS_ENV=TEST\nTAVUS_API_KEY=test-key\n"
+        "TAVUS_PUBLIC_API_BASE_URL=https://api.example.test/v2\n"
+    )
+    route = respx.post("https://api.example.test/v2/conversations").respond(
+        200, json={"conversation_id": "c-meeting", "status": "active"}
+    )
+    async with Client(mcp) as client:
+        await client.call_tool("tavus_conversation_create", {
+            "pal_id": "p-meeting",
+            "meeting_url": "https://meet.google.com/abc-defg-hij",
+        })
+    assert json.loads(route.calls.last.request.content) == {
+        "persona_id": "p-meeting",
+        "meeting_url": "https://meet.google.com/abc-defg-hij",
+    }
+
+
 @pytest.mark.asyncio
 async def test_builder_guidance_reaches_mcp_clients() -> None:
     async with Client(mcp) as client:

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/tests/unit/test_build_and_verify.py

@@ -398,6 +398,10 @@ async def test_build_uses_headless_carrier_and_pal_maker_model(
     assert len(builder_session.sent_texts) == 2
     assert routes["fanout"].call_count == 1
     fanout_body = json.loads(routes["fanout"].calls.last.request.read())
+    assert fanout_body["message"] == (
+        "Build a warm office greeter for delivery drivers. Route packages to "
+        "the lobby shelf and never request access codes."
+    )
     assert fanout_body["briefs"] == {
         "personality": "Warm office greeter for delivery drivers.",
         "objectives": "Route each delivery to the lobby shelf.",
@@ -490,6 +494,153 @@ def test_map_draft_briefs_merges_facts_into_personality() -> None:
     }
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("closeout", ["The greeting is updated.", None])
+@respx.mock
+async def test_carrier_preserves_replies_before_a_tool_followup(
+    clean_env: Path, monkeypatch: pytest.MonkeyPatch, closeout: str | None
+) -> None:
+    """Regression: tool continuations lost earlier replies, especially on timeout."""
+    _write_env(clean_env)
+    routes = _register_build_routes()
+    saved: list[dict[str, str]] = []
+
+    def append(request):
+        saved.extend(json.loads(request.content)["messages"])
+        return Response(200, json=saved)
+
+    routes["append"].mock(side_effect=append)
+    respx.get(f"{PUBLIC}/builder/b1").mock(
+        side_effect=lambda _: Response(200, json={"session": {"chat_history": saved}})
+    )
+    first = "I will keep the no-Memory decision and update the greeting."
+    turns = [
+        {
+            "text": first,
+            "tool_calls": [
+                {
+                    "name": "draft_pal",
+                    "tool_call_id": "greeting",
+                    "arguments": json.dumps({"greeting_brief": "Ask about deliveries."}),
+                }
+            ],
+        }
+    ]
+    if closeout:
+        turns.append({"text": closeout, "tool_calls": []})
+    session = FakeSession("c_builder", turns)
+
+    async def open_session(*_args: Any, **_kwargs: Any) -> FakeSession:
+        return session
+
+    monkeypatch.setattr(daily_transport, "open_conversation_session", open_session)
+    transcript: list[dict[str, Any]] = []
+    async with await _make_client() as client:
+
+        async def run():
+            return await carrier_builder.run_carrier_build(
+                client,
+                builder_id="b1",
+                pal_id="p1",
+                prompt="Change the greeting.",
+                max_rounds=1,
+                answers=[],
+                answer_provider=None,
+                on_builder_reply=None,
+                transcript=transcript,
+            )
+
+        if closeout:
+            await run()
+        else:
+            with pytest.raises(TavusError, match="No CVI reply"):
+                await run()
+        history = await client.builders.chat_history("b1")
+
+    expected = [
+        {"role": "user", "content": "Change the greeting."},
+        {"role": "assistant", "content": first},
+    ]
+    if closeout:
+        expected.append({"role": "assistant", "content": closeout})
+    assert history["messages"] == expected
+    assert [{"role": row["role"], "content": row["text"]} for row in transcript] == expected
+    assert session.closed
+    assert routes["builder_end"].called
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("max_rounds", [1, 2])
+@respx.mock
+async def test_carrier_does_not_save_automatic_nudges_as_creator_messages(
+    clean_env: Path, monkeypatch: pytest.MonkeyPatch, max_rounds: int
+) -> None:
+    """Regression: resuming a build must not attribute client instructions to its creator."""
+    _write_env(clean_env)
+    routes = _register_build_routes()
+    session = FakeSession(
+        "c_builder",
+        [
+            {"text": "Who will use this PAL?", "tool_calls": []},
+            {
+                "text": "I will draft the greeter.",
+                "tool_calls": [
+                    {
+                        "name": "draft_pal",
+                        "tool_call_id": "draft",
+                        "arguments": json.dumps({"sections_brief": "An office greeter."}),
+                    }
+                ],
+            },
+            {"text": "The greeter is ready.", "tool_calls": []},
+        ],
+    )
+
+    refinement = FakeSession("c_builder", [
+        {"text": "I will refine the greeting.", "tool_calls": [{
+            "name": "draft_pal", "tool_call_id": "refine",
+            "arguments": json.dumps({"greeting_brief": "Ask about deliveries."}),
+        }]},
+        {"text": "The greeting is ready.", "tool_calls": []},
+    ])
+    builders = iter([session, refinement])
+
+    async def open_session(conversation_id: str, *_args: Any, **_kwargs: Any) -> FakeSession:
+        if conversation_id == "c_builder":
+            return next(builders)
+        return FakeSession("c_smoke", [{"text": "Hello!", "tool_calls": []}])
+
+    routes["judge"].mock(side_effect=[
+        Response(200, json={"overall": "partial", "summary": "Improve the greeting."}),
+        Response(200, json={"overall": "pass"}),
+    ])
+    monkeypatch.setattr(daily_transport, "open_conversation_session", open_session)
+    async with await _make_client() as client:
+        result = await build_and_verify(
+            client, prompt="Build an office greeter.", face_id="rabc",
+            max_rounds=max_rounds, probes=["Hello"], auto_refine=True, max_refine_rounds=1,
+        )
+    transcript = result["build_transcript"]
+
+    saved = [
+        row
+        for call in routes["append"].calls
+        for row in json.loads(call.request.content)["messages"]
+    ]
+    assert [row for row in saved if row["role"] == "user"] == [
+        {"role": "user", "content": "Build an office greeter."},
+    ]
+    assert [row for row in transcript if row["role"] == "user"] == [
+        {"role": "user", "text": "Build an office greeter."},
+    ]
+    assert len(session.sent_texts) == 3
+    # RQH also saves this field; automated drafting must not add a fake user turn.
+    assert all(
+        json.loads(call.request.content)["message"] == "Build an office greeter."
+        for call in routes["fanout"].calls
+    )
+
+
 @pytest.mark.parametrize(
     "args",
     [

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/tests/unit/test_pal_schema.py

@@ -3,9 +3,33 @@ from __future__ import annotations
 import pytest
 from pydantic import ValidationError
 
+from tavus_mcp.sdk.patch import validate_patch_operations
 from tavus_mcp.sdk.schemas.pal import PalCreate
 
 
+def test_meeting_pal_accepts_activation_phrases_and_conferencing_settings() -> None:
+    layers = {
+        "conversational_flow": {"wake_phrase": "Hey Morgan", "sleep_phrase": "Goodbye Morgan"},
+        "conferencing": {
+            "username": "morgan-rehearsal",
+            "allowlist": ["host@example.com"],
+            "whitelabel": False,
+        },
+    }
+    pal = PalCreate.model_validate({"system_prompt": "Be a skeptical customer.", "layers": layers})
+    saved = pal.model_dump(exclude_none=True)["layers"]
+    assert saved["conversational_flow"] == layers["conversational_flow"]
+    assert saved["conferencing"] == layers["conferencing"]
+    for layer, fields in layers.items():
+        for field, value in fields.items():
+            validate_patch_operations(
+                [{"op": "add", "path": f"/layers/{layer}/{field}", "value": value}]
+            )
+    validate_patch_operations(
+        [{"op": "add", "path": "/layers/conferencing/allowlist/-", "value": "other@example.com"}]
+    )
+
+
 def test_full_pipeline_requires_system_prompt() -> None:
     with pytest.raises(ValidationError, match="system_prompt is required"):
         PalCreate.model_validate({"pal_name": "p"})

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/uv.lock

@@ -1303,7 +1303,7 @@ wheels = [
 
 [[package]]
 name = "tavus-cli"
-version = "0.10.2"
+version = "0.10.4"
 source = { editable = "." }
 dependencies = [
     { name = "fastmcp" },

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/workers/tavus-mcp/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@tavus/tavus-mcp-worker",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@tavus/tavus-mcp-worker",
-      "version": "0.10.2",
+      "version": "0.10.4",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.29.0",
         "agents": "^0.12.2",

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/workers/tavus-mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tavus/tavus-mcp-worker",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "private": true,
   "type": "module",
   "scripts": {

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/workers/tavus-mcp/src/tavus.ts

@@ -385,6 +385,12 @@ const PATCHABLE_PATHS = [
   "/layers/capabilities/mcp_enabled",
   "/layers/capabilities/search_enabled",
   "/layers/capabilities/search_results_prompt_injection_prevention_enabled",
+  "/layers/conferencing",
+  "/layers/conferencing/allowlist",
+  "/layers/conferencing/allowlist/-",
+  "/layers/conferencing/allowlist/0",
+  "/layers/conferencing/username",
+  "/layers/conferencing/whitelabel",
   "/layers/conversational_flow",
   "/layers/conversational_flow/active_listening",
   "/layers/conversational_flow/idle_engagement",
@@ -395,6 +401,7 @@ const PATCHABLE_PATHS = [
   "/layers/conversational_flow/turn_taking_patience",
   "/layers/conversational_flow/voice_isolation",
   "/layers/conversational_flow/wake_phrase",
+  "/layers/conversational_flow/sleep_phrase",
   "/layers/knowledge_base",
   "/layers/knowledge_base/enable_rag_observability_app_messages",
   "/layers/knowledge_base/rag_n_chunks",
@@ -696,7 +703,7 @@ export function createTavusMcpServer(
 
   server.tool(
     "tavus_patch_pal",
-    "Patch a PAL with validated JSON Patch operations for an exact field edit. To change what a PAL does or shows, such as adding an on-screen scorecard, use tavus_pal_build_and_verify with pal_id instead. Attach first-class tools through top-level tool_ids or tavus_pal_tools_attach; legacy layers.llm.tools writes are rejected.",
+    "Patch a PAL with validated JSON Patch operations for an exact field edit. To change what a PAL does or shows, such as adding an on-screen scorecard, use tavus_pal_build_and_verify with pal_id instead. Set wake_phrase and sleep_phrase under /layers/conversational_flow. Patch /layers/conferencing separately from behavior settings; it accepts username, allowlist, and whitelabel. Configuring an identity does not join a call. Ask the creator for the meeting link before joining. Attach first-class tools through top-level tool_ids or tavus_pal_tools_attach; legacy layers.llm.tools writes are rejected.",
     {
       pal_id: z.string().min(1),
       ops: z.array(JsonPatchOperationSchema).min(1),
@@ -1671,11 +1678,12 @@ export function createTavusMcpServer(
 
   server.tool(
     "tavus_conversation_create",
-    "Create a Tavus conversation for a pal and/or face.",
+    "Create a Tavus conversation for a PAL and/or face, or send a PAL to an existing meeting. Ask the creator for the meeting link before setting meeting_url. The PAL needs a conferencing identity and a default face. Creation confirms the request was sent; verify admission in the meeting before reporting joined.",
     {
       pal_id: z.string().optional(),
       face_id: z.string().optional(),
       conversation_name: z.string().optional(),
+      meeting_url: z.string().optional(),
     },
     {
       title: "Create conversation",
@@ -1686,7 +1694,7 @@ export function createTavusMcpServer(
     },
     // /v2/conversations is not part of the pal/face alias, so the body keeps the
     // underlying persona_id/replica_id wire fields (id values are identical).
-    async ({ pal_id, face_id, conversation_name }) =>
+    async ({ pal_id, face_id, conversation_name, meeting_url }) =>
       toolResult(
         await client.create(
           "conversations",
@@ -1694,6 +1702,7 @@ export function createTavusMcpServer(
             persona_id: pal_id,
             replica_id: face_id,
             conversation_name,
+            meeting_url,
           }),
         ),
       ),
@@ -3130,8 +3139,7 @@ async function runGuidedBuild(
 
   let probes = (options.probes ?? [])
     .map((probe) => probe.trim())
-    .filter(Boolean)
-    .slice(0, MAX_SMOKE_PROBES);
+    .filter(Boolean);
   if (!probes.length) {
     const generated = await safeCall(() =>
       client.post("persona-builder/llm/generate-probes", { persona_spec: spec }),

tavus_cli-0.10.4/workers/tavus-mcp/src/version.ts

@@ -0,0 +1 @@
+export const VERSION = "0.10.4"; // x-release-please-version

{tavus_cli-0.10.2 → tavus_cli-0.10.4}/workers/tavus-mcp/test/tavus.test.ts

@@ -72,6 +72,25 @@ function registeredTools(
 }
 
 describe("Cloudflare Tavus MCP helpers", () => {
+  it("dispatches a PAL to the requested meeting through the hosted tool", async () => {
+    const requests: Array<{ url: string; body: unknown }> = [];
+    vi.stubGlobal("fetch", vi.fn(async (input: string | URL | Request, init?: RequestInit) => {
+      requests.push({ url: String(input), body: JSON.parse(String(init?.body)) });
+      return Response.json({ conversation_id: "c-meeting", status: "active" });
+    }));
+    try {
+      const tool = registeredTools(createTavusMcpServer({ TAVUS_API_KEY: "secret" }))
+        .tavus_conversation_create;
+      await tool.handler({ pal_id: "p-meeting", meeting_url: "https://meet.google.com/abc-defg-hij" });
+      expect(requests).toEqual([{
+        url: "https://tavusapi.com/v2/conversations",
+        body: { persona_id: "p-meeting", meeting_url: "https://meet.google.com/abc-defg-hij" },
+      }]);
+    } finally {
+      vi.unstubAllGlobals();
+    }
+  });
+
   it("reads RQH builder history across MCP sessions and saves creator turns there", async () => {
     const history = [{ role: "assistant", content: "Would you like Memory?" }];
     vi.stubGlobal("fetch", vi.fn(async (input: string | URL | Request, init?: RequestInit) => {
@@ -591,7 +610,8 @@ describe("Cloudflare Tavus MCP helpers", () => {
       await expect(build({ pal_id: "p_live", prompt: request })).rejects.toThrow(/at least one brief/);
       expect(calls).toEqual([]);
 
-      const pending = build({ pal_id: "p_live", prompt: request, briefs: { skills: request }, probes: ["Score me."] });
+      const probes = ["Start practice.", "My first answer.", "My second answer.", "Score me.", "Wrap up."];
+      const pending = build({ pal_id: "p_live", prompt: request, briefs: { skills: request }, probes });
       let settled = false;
       void pending.finally(() => {
         settled = true;
@@ -600,6 +620,9 @@ describe("Cloudflare Tavus MCP helpers", () => {
         await vi.advanceTimersByTimeAsync(500);
       }
       const result = JSON.parse((await pending).content[0].text);
+      expect(result.probes).toEqual(probes);
+      expect(result.smoke_transcript.filter((turn: { role: string }) => turn.role === "user")
+        .map((turn: { text: string }) => turn.text)).toEqual(probes);
 
       expect(calls.find((call) => call.path === "/builder")?.body).toEqual({
         name: "Leasing Coach",
@@ -648,6 +671,24 @@ describe("Cloudflare Tavus MCP helpers", () => {
     ).toThrow(/Unsupported pal patch path/);
   });
 
+  it("accepts meeting settings and rejects unsupported leaf paths", () => {
+    const ops = [
+      { op: "add" as const, path: "/layers/conversational_flow/wake_phrase", value: "Hey Morgan" },
+      { op: "add" as const, path: "/layers/conversational_flow/sleep_phrase", value: "Goodbye Morgan" },
+      { op: "add" as const, path: "/layers/conferencing", value: { username: "morgan-rehearsal" } },
+      { op: "replace" as const, path: "/layers/conferencing/username", value: "morgan-demo" },
+      { op: "replace" as const, path: "/layers/conferencing/allowlist", value: ["host@example.com"] },
+      { op: "add" as const, path: "/layers/conferencing/allowlist/-", value: "other@example.com" },
+      { op: "replace" as const, path: "/layers/conferencing/whitelabel", value: false },
+    ];
+    expect(validatePatchOperations(ops)).toEqual(ops);
+    for (const field of ["email", "aliased_from", "usernmae"]) {
+      expect(() => validatePatchOperations([
+        { op: "replace", path: `/layers/conferencing/${field}`, value: "invalid" },
+      ])).toThrow(/Unsupported pal patch path/);
+    }
+  });
+
   it("patches guardrails by id and tag, not by the removed grouped id", () => {
     expect(
       validatePatchOperations([

tavus_cli-0.10.2/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.10.2"
-}

tavus_cli-0.10.2/workers/tavus-mcp/src/version.ts

@@ -1 +0,0 @@
-export const VERSION = "0.10.2"; // x-release-please-version