tavus-cli 0.3.4__tar.gz → 0.4.1__tar.gz

{tavus_cli-0.3.4 → tavus_cli-0.4.1}/.github/workflows/pypi-cli.yml

@@ -149,7 +149,7 @@ jobs:
 
           PARENT_SHA=$(git rev-parse "$RELEASE_SHA^")
           UNEXPECTED=$(git diff --name-only "$PARENT_SHA" "$RELEASE_SHA" | grep -Ev \
-            '^(\.release-please-manifest\.json|CHANGELOG\.md|pyproject\.toml|uv\.lock|src/tavus_mcp/__init__\.py|workers/tavus-mcp/package\.json|workers/tavus-mcp/package-lock\.json|workers/tavus-mcp/src/version\.ts)$' || true)
+            '^(\.release-please-manifest\.json|CHANGELOG\.md|pyproject\.toml|uv\.lock|src/tavus_mcp/__init__\.py|workers/tavus-mcp/package\.json|workers/tavus-mcp/package-lock\.json|workers/tavus-mcp/src/version\.ts|packages/tavus/pyproject\.toml|packages/tavus-mcp/pyproject\.toml)$' || true)
           if [ -n "$UNEXPECTED" ]; then
             echo "::error::The release commit contains files that were not staged:"
             echo "$UNEXPECTED"
@@ -195,7 +195,10 @@ jobs:
         run: uv run pytest -q
 
       - name: Build Python distributions
-        run: uv build
+        run: |
+          uv build
+          uv build packages/tavus --out-dir dist
+          uv build packages/tavus-mcp --out-dir dist
 
       - name: Set up Node.js
         uses: actions/setup-node@v4
@@ -316,9 +319,55 @@ jobs:
           name: tavus-cli-${{ needs.preflight.outputs.release_version }}
           path: dist
 
-      - name: Publish Tavus CLI to PyPI
+      - 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.1/.release-please-manifest.json

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

{tavus_cli-0.3.4 → tavus_cli-0.4.1}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [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)
+
+
+### Features
+
+* notify cvi-automations after MCP deploys ([#41](https://github.com/Tavus-Engineering/tavus-mcp/issues/41)) ([169d092](https://github.com/Tavus-Engineering/tavus-mcp/commit/169d092b6b9241256316e3d8f6a0a633319b70ef))
+* publish tavus and tavus-mcp alias packages ([2c781a0](https://github.com/Tavus-Engineering/tavus-mcp/commit/2c781a059b1ef06acd2d4293239e41d568c4f0ce))
+
 ## [0.3.4](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.3.3...v0.3.4) (2026-08-25)
 
 

{tavus_cli-0.3.4 → tavus_cli-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tavus-cli
-Version: 0.3.4
+Version: 0.4.1
 Summary: Tavus CLI and MCP server for agentic PAL creation and editing.
 Requires-Python: >=3.11
 Requires-Dist: fastmcp>=2.0.0
@@ -112,6 +112,10 @@ uv tool install tavus-cli
 uvx --from tavus-cli tavus doctor
 ```
 
+The `tavus` and `tavus-mcp` names on PyPI are official alias packages
+(`packages/`) that only depend on `tavus-cli`; every release publishes all
+three at the same version.
+
 Sign in with `tavus auth login`. It opens the developer portal at
 `/dev/cli-authorize` with a loopback callback; the portal mints an API key for
 your signed-in user and the CLI stores it in the OS keychain, per environment.

{tavus_cli-0.3.4 → tavus_cli-0.4.1}/README.md

@@ -90,6 +90,10 @@ uv tool install tavus-cli
 uvx --from tavus-cli tavus doctor
 ```
 
+The `tavus` and `tavus-mcp` names on PyPI are official alias packages
+(`packages/`) that only depend on `tavus-cli`; every release publishes all
+three at the same version.
+
 Sign in with `tavus auth login`. It opens the developer portal at
 `/dev/cli-authorize` with a loopback callback; the portal mints an API key for
 your signed-in user and the CLI stores it in the OS keychain, per environment.

tavus_cli-0.4.1/packages/tavus/README.md

@@ -0,0 +1,14 @@
+# tavus
+
+Official alias for [`tavus-cli`](https://pypi.org/project/tavus-cli/), the
+Tavus CLI and MCP server. Installing this package installs `tavus-cli`, which
+provides the `tavus` command and the `tavus-mcp` MCP server.
+
+Prefer installing the real package directly:
+
+```bash
+uv tool install tavus-cli
+```
+
+Source and documentation:
+<https://github.com/Tavus-Engineering/tavus-mcp>

tavus_cli-0.4.1/packages/tavus/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "tavus"
+version = "0.4.1" # 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.1", # x-release-please-version
+]
+
+[project.urls]
+Homepage = "https://github.com/Tavus-Engineering/tavus-mcp"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+# Metadata-only alias package: it ships no code of its own.
+[tool.hatch.build.targets.wheel]
+bypass-selection = true

tavus_cli-0.4.1/packages/tavus-mcp/README.md

@@ -0,0 +1,17 @@
+# tavus-mcp
+
+Official alias for [`tavus-cli`](https://pypi.org/project/tavus-cli/).
+Installing this package installs `tavus-cli`, which provides the `tavus-mcp`
+stdio MCP server and the `tavus` command.
+
+Prefer installing the real package directly:
+
+```bash
+uvx --from 'tavus-cli[daily]' tavus-mcp
+```
+
+The hosted MCP server needs no install at all: point your MCP client at
+`https://mcp.tavus.io/mcp`.
+
+Source and documentation:
+<https://github.com/Tavus-Engineering/tavus-mcp>

tavus_cli-0.4.1/packages/tavus-mcp/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "tavus-mcp"
+version = "0.4.1" # 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.1", # x-release-please-version
+]
+
+[project.urls]
+Homepage = "https://github.com/Tavus-Engineering/tavus-mcp"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+# Metadata-only alias package: it ships no code of its own.
+[tool.hatch.build.targets.wheel]
+bypass-selection = true

{tavus_cli-0.3.4 → tavus_cli-0.4.1}/pyproject.toml

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

{tavus_cli-0.3.4 → tavus_cli-0.4.1}/release-please-config.json

@@ -29,6 +29,14 @@
         {
           "type": "generic",
           "path": "workers/tavus-mcp/src/version.ts"
+        },
+        {
+          "type": "generic",
+          "path": "packages/tavus/pyproject.toml"
+        },
+        {
+          "type": "generic",
+          "path": "packages/tavus-mcp/pyproject.toml"
         }
       ]
     }

{tavus_cli-0.3.4 → tavus_cli-0.4.1}/scripts/check_release_versions.py

@@ -42,7 +42,7 @@ def collect_versions() -> dict[str, str]:
     if not python_init or not worker_source or not lock_package:
         raise ValueError("Could not read one or more release version fields")
 
-    return {
+    versions = {
         "release-please manifest": str(manifest["."]),
         "pyproject.toml": str(pyproject["project"]["version"]),
         "Python package": python_init.group(1),
@@ -52,6 +52,17 @@ def collect_versions() -> dict[str, str]:
         "Worker package-lock root package": str(worker_lock["packages"][""]["version"]),
         "Worker runtime": worker_source.group(1),
     }
+    for alias in ("tavus", "tavus-mcp"):
+        alias_project = tomllib.loads(_read(f"packages/{alias}/pyproject.toml"))["project"]
+        pin = next(
+            (dep for dep in alias_project["dependencies"] if dep.startswith("tavus-cli==")),
+            None,
+        )
+        if pin is None:
+            raise ValueError(f"Alias package {alias} does not pin tavus-cli")
+        versions[f"{alias} alias package"] = str(alias_project["version"])
+        versions[f"{alias} alias tavus-cli pin"] = pin.removeprefix("tavus-cli==")
+    return versions
 
 
 def check_versions(expected: str | None = None) -> str:

{tavus_cli-0.3.4 → tavus_cli-0.4.1}/src/tavus_mcp/__init__.py

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

{tavus_cli-0.3.4 → tavus_cli-0.4.1}/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.3.4 → tavus_cli-0.4.1}/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.3.4 → tavus_cli-0.4.1}/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.3.4 → tavus_cli-0.4.1}/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()