tavus-cli 0.4.0__tar.gz → 0.4.2__tar.gz

{tavus_cli-0.4.0 → tavus_cli-0.4.2}/.github/workflows/pypi-cli.yml

@@ -322,52 +322,6 @@ jobs:
       - name: Publish Tavus CLI and its alias packages to PyPI
         run: uv publish --trusted-publishing always --check-url https://pypi.org/simple/ dist/*
 
-  notify-cvi-automations:
-    name: 'Notify #cvi-automations (prod deploy)'
-    needs: [preflight, production]
-    if: ${{ always() && !cancelled() && needs.preflight.result == 'success' }}
-    runs-on: ubuntu-latest
-    # A Slack or mention-resolution failure must not change the deploy result.
-    continue-on-error: true
-    timeout-minutes: 5
-    steps:
-      - name: Resolve release author mentions
-        id: mentions
-        continue-on-error: true
-        timeout-minutes: 2
-        uses: Tavus-Engineering/pr-changelog-action/release-mentions@main
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          deploy-tag: ${{ needs.preflight.outputs.release_tag }}
-          environment: prod
-
-      - name: 'Post outcome to #cvi-automations'
-        env:
-          SLACK_BOT_TOKEN: ${{ secrets.CVI_BOT_SLACK_TOKEN }}
-          MENTIONS: ${{ steps.mentions.outputs.mentions }}
-          DEPLOY_RESULT: ${{ needs.production.result }}
-          RELEASE_TAG: ${{ needs.preflight.outputs.release_tag }}
-          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
-        run: |
-          set -euo pipefail
-          AUTHOR_TAGS="${MENTIONS:+${MENTIONS} }"
-          CVI_TEAM="<!subteam^S08HUM36HMZ>"
-          if [ "$DEPLOY_RESULT" = "success" ]; then
-            TEXT=":white_check_mark: ${AUTHOR_TAGS}Tavus MCP <${RUN_URL}|${RELEASE_TAG}> is live in production."
-          else
-            TEXT=":x: ${CVI_TEAM} Tavus MCP production deploy failed — <${RUN_URL}|run>."
-          fi
-
-          RESPONSE=$(curl --fail-with-body --silent --show-error \
-            --connect-timeout 5 --max-time 30 \
-            -X POST https://slack.com/api/chat.postMessage \
-            -H "Authorization: Bearer ${SLACK_BOT_TOKEN}" \
-            -H "Content-Type: application/json; charset=utf-8" \
-            --data "$(jq -n --arg channel "C0B9S5Y556V" --arg text "$TEXT" \
-              '{channel:$channel, text:$text, unfurl_links:false}')")
-          echo "$RESPONSE" | jq .
-          echo "$RESPONSE" | jq -e '.ok == true' >/dev/null
-
   update-final-board:
     name: Refresh Slack after production
     needs: [preflight, update-pending-board, production]

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

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

{tavus_cli-0.4.0 → tavus_cli-0.4.2}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.4.2](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.4.1...v0.4.2) (2026-08-28)
+
+
+### Reverts
+
+* "feat: notify cvi-automations after MCP deploys" ([5aa2112](https://github.com/Tavus-Engineering/tavus-mcp/commit/5aa2112d044e0c956f6e6a1ac4d792c626aa7728))
+
+## [0.4.1](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.4.0...v0.4.1) (2026-08-27)
+
+
+### Bug Fixes
+
+* make MCP list tools compact and complete ([#33](https://github.com/Tavus-Engineering/tavus-mcp/issues/33)) ([9798cad](https://github.com/Tavus-Engineering/tavus-mcp/commit/9798cad82540a188162b1758731f04ae59f082f3))
+
 ## [0.4.0](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.3.4...v0.4.0) (2026-08-26)
 
 

{tavus_cli-0.4.0 → tavus_cli-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tavus-cli
-Version: 0.4.0
+Version: 0.4.2
 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.4.0 → tavus_cli-0.4.2}/packages/tavus/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "tavus"
-version = "0.4.0" # x-release-please-version
+version = "0.4.2" # 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.4.0", # x-release-please-version
+  "tavus-cli==0.4.2", # x-release-please-version
 ]
 
 [project.urls]

{tavus_cli-0.4.0 → tavus_cli-0.4.2}/packages/tavus-mcp/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "tavus-mcp"
-version = "0.4.0" # x-release-please-version
+version = "0.4.2" # 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.4.0", # x-release-please-version
+  "tavus-cli==0.4.2", # x-release-please-version
 ]
 
 [project.urls]

{tavus_cli-0.4.0 → tavus_cli-0.4.2}/pyproject.toml

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

{tavus_cli-0.4.0 → tavus_cli-0.4.2}/src/tavus_mcp/__init__.py

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

{tavus_cli-0.4.0 → tavus_cli-0.4.2}/src/tavus_mcp/cli/main.py

@@ -1462,7 +1462,7 @@ def tool_list(
     page: int = typer.Option(1),
     type: str = typer.Option("user", help="user | system | all"),
     name_or_uuid: str | None = typer.Option(None),
-    sort: str = typer.Option("ascending"),
+    sort: str = typer.Option("asc"),
     json_output: bool = typer.Option(False, "--json"),
 ) -> None:
     """List tools."""

{tavus_cli-0.4.0 → tavus_cli-0.4.2}/src/tavus_mcp/sdk/client/http.py

@@ -27,6 +27,20 @@ BUILDER_LLM_TIMEOUT_S = 120.0
 CLIENT_SOURCE_HEADER = "X-Tavus-Client-Source"
 
 
+def _public_pal_error_body(value: Any) -> Any:
+    """Keep internal persona vocabulary out of public PAL errors."""
+    if isinstance(value, str):
+        return value.replace("persona_id", "pal_id")
+    if isinstance(value, list):
+        return [_public_pal_error_body(item) for item in value]
+    if isinstance(value, dict):
+        return {
+            str(key).replace("persona_id", "pal_id"): _public_pal_error_body(item)
+            for key, item in value.items()
+        }
+    return value
+
+
 def _package_version() -> str:
     try:
         return version("tavus-cli")
@@ -128,6 +142,8 @@ class TavusClient:
                 body: Any = response.json()
             except ValueError:
                 body = response.text
+            if path.strip("/").startswith("pals"):
+                body = _public_pal_error_body(body)
             raise TavusApiError(
                 f"Tavus API {method.upper()} {path} failed with {response.status_code}",
                 status_code=response.status_code,
@@ -149,6 +165,40 @@ class Resource:
     async def list(self, **params: Any) -> Any:
         return await self.client.request("GET", f"/{self.name}", params=_clean(params))
 
+    async def list_all(
+        self,
+        *,
+        page_size: int = 100,
+        start_page: int = 1,
+        **params: Any,
+    ) -> dict[str, Any]:
+        """Collect a 1-indexed paginated resource without hiding later pages."""
+        data: list[Any] = []
+        total_count: int | None = None
+        for page in range(start_page, start_page + 100):
+            response = await self.list(limit=page_size, page=page, **params)
+            page_data = (
+                response.get("data", [])
+                if isinstance(response, dict)
+                else response
+                if isinstance(response, list)
+                else []
+            )
+            if not isinstance(page_data, list):
+                page_data = []
+            data.extend(page_data)
+            if isinstance(response, dict) and isinstance(response.get("total_count"), int):
+                total_count = response["total_count"]
+            if not page_data:
+                break
+            if total_count is not None and len(data) >= total_count:
+                break
+            if len(page_data) < page_size:
+                break
+        else:
+            raise RuntimeError(f"Tavus API {self.name} pagination exceeded 100 pages")
+        return {"data": data, "total_count": total_count or len(data)}
+
     async def get(self, resource_id: str, **params: Any) -> Any:
         return await self.client.request(
             "GET",

{tavus_cli-0.4.0 → tavus_cli-0.4.2}/src/tavus_mcp/sdk/schemas/tool.py

@@ -249,7 +249,7 @@ class ToolListParams(BaseModel):
     limit: int = 25
     page: int = 1
     type: ToolListType = "user"
-    sort: Literal["ascending", "descending"] = "ascending"
+    sort: Literal["asc", "desc"] = "asc"
     name_or_uuid: str | None = None
 
 

{tavus_cli-0.4.0 → tavus_cli-0.4.2}/src/tavus_mcp/server.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import time
-from typing import Any
+from typing import Any, Literal
 
 from fastmcp import FastMCP
 
@@ -31,7 +31,105 @@ from tavus_mcp.sdk.recipes.scaffold_embed import EmbedTarget, scaffold_embed
 from tavus_mcp.sdk.recipes.templates import PalTemplate, pal_from_template
 from tavus_mcp.sdk.recipes.tool_reuse import build_library_match_advisory
 
-mcp = FastMCP(
+_READ_ONLY_TOOL_NAMES = {
+    "tavus_mcp_health_check",
+    "tavus_pal_list",
+    "tavus_pal_get",
+    "tavus_describe_pal_options",
+    "tavus_document_list",
+    "tavus_document_get",
+    "tavus_document_tags",
+    "tavus_document_chunks",
+    "tavus_pal_knowledge_list",
+    "tavus_skill_list",
+    "tavus_skill_get",
+    "tavus_pal_skills_list",
+    "tavus_pal_capability_catalog",
+    "tavus_pal_capabilities_list",
+    "tavus_face_list",
+    "tavus_scaffold_embed",
+    "tavus_resource_list",
+    "tavus_voice_list",
+    "tavus_guardrail_list",
+    "tavus_guardrail_get",
+    "tavus_guardrail_tags",
+    "tavus_objective_list",
+    "tavus_objective_get",
+    "tavus_objective_validate",
+    "tavus_tool_list",
+    "tavus_tool_get",
+    "tavus_pronunciation_dictionary_list",
+    "tavus_pronunciation_dictionary_get",
+    "tavus_pal_tools_list",
+    "tavus_builder_list",
+    "tavus_builder_get",
+    "tavus_builder_chat_history",
+}
+
+_DESTRUCTIVE_TOOL_NAMES = {
+    "tavus_pal_delete",
+    "tavus_pal_knowledge_remove",
+    "tavus_pal_knowledge_replace",
+    "tavus_pal_skill_detach",
+    "tavus_pal_capability_detach",
+    "tavus_conversation_end",
+    "tavus_guardrail_delete",
+    "tavus_objective_delete",
+    "tavus_tool_delete",
+    "tavus_pronunciation_dictionary_delete",
+    "tavus_pal_tools_detach",
+    "tavus_builder_delete",
+    "tavus_chat_end",
+}
+
+
+def _annotations_for_tool(name: str) -> dict[str, bool]:
+    if name in _READ_ONLY_TOOL_NAMES:
+        return {
+            "readOnlyHint": True,
+            "destructiveHint": False,
+            "idempotentHint": True,
+            "openWorldHint": True,
+        }
+    if name in _DESTRUCTIVE_TOOL_NAMES:
+        return {
+            "readOnlyHint": False,
+            "destructiveHint": True,
+            "idempotentHint": True,
+            "openWorldHint": True,
+        }
+    return {
+        "readOnlyHint": False,
+        "destructiveHint": False,
+        "idempotentHint": False,
+        "openWorldHint": True,
+    }
+
+
+class AnnotatedFastMCP(FastMCP):
+    """Apply a conservative annotation policy to every registered Tavus tool."""
+
+    def tool(self, name_or_fn: Any = None, **kwargs: Any) -> Any:
+        if name_or_fn is None and kwargs.get("annotations") is None:
+
+            def register(fn: Any) -> Any:
+                return super(AnnotatedFastMCP, self).tool(
+                    fn,
+                    annotations=_annotations_for_tool(kwargs.get("name") or fn.__name__),
+                    **kwargs,
+                )
+
+            return register
+        if callable(name_or_fn) and kwargs.get("annotations") is None:
+            kwargs["annotations"] = _annotations_for_tool(
+                kwargs.get("name") or name_or_fn.__name__
+            )
+        elif isinstance(name_or_fn, str) and kwargs.get("annotations") is None:
+            kwargs["annotations"] = _annotations_for_tool(name_or_fn)
+        return super().tool(name_or_fn, **kwargs)
+
+
+mcp = AnnotatedFastMCP(
     "tavus",
     instructions=(
         "PAL tools are first-class objects, not inlined on the PAL. "
@@ -63,6 +161,47 @@ def _list_data(value: Any) -> list[Any]:
     return []
 
 
+def _summary_value(item: dict[str, Any], *names: str) -> Any:
+    for name in names:
+        if name in item:
+            return item[name]
+    return None
+
+
+def _compact_list(value: Any, summarize: Any) -> dict[str, Any]:
+    data = [summarize(item) for item in _list_data(value) if isinstance(item, dict)]
+    result: dict[str, Any] = {"data": data, "returned_count": len(data)}
+    if isinstance(value, dict) and isinstance(value.get("total_count"), int):
+        result["total_count"] = value["total_count"]
+    else:
+        result["total_count"] = len(data)
+    return result
+
+
+def _pal_summary(item: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "pal_id": _summary_value(item, "pal_id", "persona_id", "uuid"),
+        "name": _summary_value(item, "name", "pal_name", "persona_name"),
+        "description": _summary_value(
+            item,
+            "description",
+            "pal_description",
+            "persona_description",
+        ),
+        "is_published": item.get("is_published"),
+        "pipeline_mode": item.get("pipeline_mode"),
+        "updated_at": item.get("updated_at"),
+    }
+
+
+def _tool_summary(item: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "tool_id": _summary_value(item, "tool_id", "uuid"),
+        "name": item.get("name"),
+        "is_system_tool": item.get("is_system_tool"),
+    }
+
+
 def _response_shape(value: Any) -> str:
     if isinstance(value, list):
         return "list"
@@ -147,8 +286,10 @@ async def tavus_pal_list(
     page: int = 0,
     pal_type: str | None = None,
 ) -> Any:
+    """List compact PAL summaries. Use ``tavus_pal_get`` for full settings."""
     async with TavusClient.from_env(surface="mcp") as client:
-        return await client.pals.list(limit=limit, page=page, pal_type=pal_type)
+        response = await client.pals.list(limit=limit, page=page, pal_type=pal_type)
+    return _compact_list(response, _pal_summary)
 
 
 @mcp.tool()
@@ -974,23 +1115,31 @@ async def tavus_objective_validate(
 
 @mcp.tool()
 async def tavus_tool_list(
-    limit: int = 25,
+    limit: int | None = None,
     page: int = 1,
     type: str = "user",
     name_or_uuid: str | None = None,
-    sort: str = "ascending",
+    sort: Literal["asc", "desc"] = "asc",
 ) -> Any:
-    """List tools. `type` is "user" / "system" / "all"."""
+    """List compact tool summaries.
+
+    Omit ``limit`` to return every matching tool across all API pages. Set
+    ``limit`` and ``page`` when one explicit page is enough. ``type`` accepts
+    ``"user"``, ``"system"``, or ``"all"``; ``sort`` accepts ``"asc"`` or
+    ``"desc"``. Use ``tavus_tool_get`` for the full tool definition.
+    """
     params: dict[str, Any] = {
-        "limit": limit,
-        "page": page,
         "type": type,
         "sort": sort,
     }
     if name_or_uuid:
         params["name_or_uuid"] = name_or_uuid
     async with TavusClient.from_env(surface="mcp") as client:
-        return await client.tools.list(**params)
+        if limit is None:
+            response = await client.tools.list_all(**params)
+        else:
+            response = await client.tools.list(limit=limit, page=page, **params)
+    return _compact_list(response, _tool_summary)
 
 
 @mcp.tool()

tavus_cli-0.4.2/tests/integration/test_mcp_server.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+import respx
+from httpx import Response
+
+from tavus_mcp.sdk.errors import TavusApiError
+from tavus_mcp.server import (
+    mcp,
+    tavus_pal_create,
+    tavus_pal_get,
+    tavus_pal_list,
+    tavus_tool_list,
+)
+
+
+@pytest.mark.asyncio
+async def test_mcp_server_imports_and_registers_tools() -> None:
+    tools = {tool.name: tool for tool in await mcp.list_tools()}
+
+    assert "tavus_mcp_health_check" in tools
+    assert "tavus_pal_list" in tools
+    assert "tavus_describe_pal_options" in tools
+    assert "tavus_skill_list" in tools
+    assert "tavus_document_list" in tools
+    assert "tavus_document_upload" in tools
+    assert "tavus_document_chunks" in tools
+    assert "tavus_pal_knowledge_list" in tools
+    assert "tavus_pal_knowledge_add" in tools
+    assert "tavus_pal_knowledge_remove" in tools
+    assert "tavus_pal_skills_list" in tools
+    assert "tavus_pal_capabilities_list" in tools
+    assert "tavus_pal_capability_attach" in tools
+    assert "tavus_pal_capability_detach" in tools
+    assert "tavus_pal_from_template" in tools
+    assert "tavus_scaffold_embed" in tools
+    build_schema = tools["tavus_pal_build_and_verify"].parameters
+    assert "probes" in build_schema["properties"]
+    assert tools["tavus_tool_list"].parameters["properties"]["sort"]["enum"] == [
+        "asc",
+        "desc",
+    ]
+
+    assert all(tool.annotations is not None for tool in tools.values())
+    health_annotations = tools["tavus_mcp_health_check"].annotations
+    assert health_annotations.readOnlyHint is True
+    assert health_annotations.destructiveHint is False
+    assert health_annotations.idempotentHint is True
+    assert health_annotations.openWorldHint is True
+    assert tools["tavus_pal_create"].annotations.readOnlyHint is False
+    assert tools["tavus_pal_create"].annotations.destructiveHint is False
+    assert tools["tavus_pal_delete"].annotations.destructiveHint is True
+
+
+@pytest.mark.asyncio
+@respx.mock
+async def test_mcp_requests_identify_the_mcp_surface(clean_env: Path) -> None:
+    (clean_env / ".env").write_text(
+        "TAVUS_ENV=TEST\n"
+        "TAVUS_API_KEY=test-key\n"
+        "TAVUS_PUBLIC_API_BASE_URL=https://api.example.test/v2\n"
+    )
+    route = respx.get("https://api.example.test/v2/pals").mock(
+        return_value=Response(
+            200,
+            json={
+                "data": [
+                    {
+                        "pal_id": "p-summary",
+                        "pal_name": "Summary PAL",
+                        "pal_description": "A compact example.",
+                        "is_published": True,
+                        "pipeline_mode": "full",
+                        "updated_at": "2026-08-25T12:00:00Z",
+                        "system_prompt": "This must not appear in a list response.",
+                        "context": "Nor should this.",
+                        "layers": {"llm": {"model": "private-detail"}},
+                        "owner_id": 123,
+                    }
+                ],
+                "total_count": 312,
+            },
+        )
+    )
+
+    assert await tavus_pal_list() == {
+        "data": [
+            {
+                "pal_id": "p-summary",
+                "name": "Summary PAL",
+                "description": "A compact example.",
+                "is_published": True,
+                "pipeline_mode": "full",
+                "updated_at": "2026-08-25T12:00:00Z",
+            }
+        ],
+        "returned_count": 1,
+        "total_count": 312,
+    }
+    request = route.calls.last.request
+    assert request.headers["user-agent"].startswith("tavus-mcp/")
+    assert request.headers["x-tavus-client-source"] == "mcp"
+
+
+@pytest.mark.asyncio
+@respx.mock
+async def test_tool_list_collects_every_page_and_returns_summaries(clean_env: Path) -> None:
+    (clean_env / ".env").write_text(
+        "TAVUS_ENV=TEST\n"
+        "TAVUS_API_KEY=test-key\n"
+        "TAVUS_PUBLIC_API_BASE_URL=https://api.example.test/v2\n"
+    )
+    first_page = [
+        {
+            "tool_id": f"t-{index}",
+            "name": f"tool_{index}",
+            "description": f"Tool {index}",
+            "origin": "llm",
+            "trigger_type": "in_call",
+            "is_system_tool": False,
+            "updated_at": "2026-08-25T12:00:00Z",
+            "parameters": {"large": "detail"},
+            "owner_id": 123,
+        }
+        for index in range(100)
+    ]
+    route = respx.get("https://api.example.test/v2/tools").mock(
+        side_effect=[
+            Response(200, json={"data": first_page, "total_count": 101}),
+            Response(
+                200,
+                json={
+                    "data": [
+                        {
+                            "tool_id": "t-100",
+                            "name": "tool_100",
+                            "description": "Tool 100",
+                            "origin": "llm",
+                            "trigger_type": "in_call",
+                            "is_system_tool": False,
+                            "updated_at": "2026-08-25T12:00:00Z",
+                            "parameters": {"large": "detail"},
+                        }
+                    ],
+                    "total_count": 101,
+                },
+            ),
+        ]
+    )
+
+    result = await tavus_tool_list(sort="desc")
+
+    assert result["returned_count"] == 101
+    assert result["total_count"] == 101
+    assert result["data"][-1] == {
+        "tool_id": "t-100",
+        "name": "tool_100",
+        "is_system_tool": False,
+    }
+    assert len(route.calls) == 2
+    assert route.calls[0].request.url.params["sort"] == "desc"
+    assert route.calls[0].request.url.params["page"] == "1"
+    assert route.calls[1].request.url.params["page"] == "2"
+    assert "parameters" not in result["data"][-1]
+
+
+@pytest.mark.asyncio
+@respx.mock
+async def test_pal_get_uses_public_vocabulary_in_errors(clean_env: Path) -> None:
+    (clean_env / ".env").write_text(
+        "TAVUS_ENV=TEST\n"
+        "TAVUS_API_KEY=test-key\n"
+        "TAVUS_PUBLIC_API_BASE_URL=https://api.example.test/v2\n"
+    )
+    respx.get("https://api.example.test/v2/pals/p-missing").mock(
+        return_value=Response(400, json={"message": "Invalid persona_id"})
+    )
+
+    with pytest.raises(TavusApiError) as error:
+        await tavus_pal_get("p-missing")
+
+    assert error.value.status_code == 400
+    assert error.value.body == {"message": "Invalid pal_id"}
+
+
+@pytest.mark.asyncio
+@respx.mock
+async def test_pal_create_returns_matching_pal_maker_url(clean_env: Path) -> None:
+    (clean_env / ".env").write_text(
+        "TAVUS_ENV=PROD\n"
+        "TAVUS_API_KEY=test-key\n"
+        "TAVUS_PUBLIC_API_BASE_URL=https://api.example.test/v2\n"
+        "TAVUS_PAL_MAKER_URL=https://maker.example.test\n"
+    )
+    respx.post("https://api.example.test/v2/pals").mock(
+        return_value=Response(
+            200,
+            json={"pal_id": "p-created", "pal_name": "Builder Link Test"},
+        )
+    )
+
+    created = await tavus_pal_create(
+        system_prompt="You are a test PAL.",
+        pal_name="Builder Link Test",
+    )
+
+    assert created == {
+        "pal_id": "p-created",
+        "pal_name": "Builder Link Test",
+        "pal_url": "https://maker.example.test/dev/pals/update?pal_id=p-created",
+    }