tavus-cli 0.7.0__tar.gz → 0.8.0__tar.gz

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

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

{tavus_cli-0.7.0 → tavus_cli-0.8.0}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.8.0](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.7.0...v0.8.0) (2026-10-08)
+
+
+### Features
+
+* create deployments from MCP so agents can put a PAL on a site ([#59](https://github.com/Tavus-Engineering/tavus-mcp/issues/59)) ([15079b3](https://github.com/Tavus-Engineering/tavus-mcp/commit/15079b3ce3dc941a6c59ad5278241923a93e715d))
+* **worker:** accept sign-in from VS Code, v0, Lovable and Replit ([#61](https://github.com/Tavus-Engineering/tavus-mcp/issues/61)) ([c220a74](https://github.com/Tavus-Engineering/tavus-mcp/commit/c220a74cb8835767583adf242586c4b2484dea4d))
+
+
+### Bug Fixes
+
+* **guardrails:** let the hosted server patch guardrail_ids and drop guardrails_id ([#12](https://github.com/Tavus-Engineering/tavus-mcp/issues/12)) ([ae389a5](https://github.com/Tavus-Engineering/tavus-mcp/commit/ae389a5399eae609f416b59a59b4e77dd3001a37))
+
+
+### Documentation
+
+* add a coding-agent prompt for the MCP server ([#58](https://github.com/Tavus-Engineering/tavus-mcp/issues/58)) ([293f2eb](https://github.com/Tavus-Engineering/tavus-mcp/commit/293f2eb6d8804f85cc444382cbf9cd84ee2598e4))
+
 ## [0.7.0](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.6.0...v0.7.0) (2026-10-07)
 
 

{tavus_cli-0.7.0 → tavus_cli-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tavus-cli
-Version: 0.7.0
+Version: 0.8.0
 Summary: Tavus CLI and MCP server for agentic PAL creation and editing.
 Requires-Python: >=3.11
 Requires-Dist: fastmcp>=2.0.0
@@ -29,8 +29,9 @@ MCP-aware client) drive the same platform through the API:
 - **MCP server.** The full PAL surface as MCP tools: the guided build
   (`tavus_pal_build_and_verify`), chat-mode text testing, and CRUD for PALs,
   tools, knowledge, guardrails, objectives, pronunciation dictionaries,
-  capabilities, faces, and voices. Run it locally over stdio, or connect to
-  the hosted server at `https://mcp.tavus.io/mcp`.
+  capabilities, faces, and voices, plus deployments that put a PAL on a
+  landing page, an embed or a widget. Run it locally over stdio, or connect
+  to the hosted server at `https://mcp.tavus.io/mcp`.
 - **`tavus` CLI.** The same surface as shell commands, published to PyPI as
   [`tavus-cli`](https://pypi.org/project/tavus-cli/). Scripted PAL authoring
   and publishing, JSON round-tripping, browser login with OS-keychain storage.
@@ -56,9 +57,28 @@ OAuth metadata and dynamic client registration, so the client sends you
 through Tavus browser sign-in. The developer portal mints a per-user API key;
 the Worker keeps it encrypted server-side and issues expiring OAuth tokens.
 The API key never appears in client configuration or browser callback URLs.
-Claude and ChatGPT callback
-URLs are accepted automatically; other hosted clients must be registered
-through `MCP_OAUTH_CLIENTS`.
+
+Dynamic client registration accepts loopback callbacks from any local client
+(Claude Code, Codex, Gemini CLI) and the hosted callbacks of Claude, ChatGPT,
+Cursor, VS Code, v0, Lovable and Replit. They are listed in `KNOWN_REMOTE_CLIENTS` in
+`workers/tavus-mcp/src/oauth.ts`. To add a client, press Connect in it once,
+read its callback from the Worker's `oauth_register_rejected` log line, and add
+an entry with a test. Clients that don't use dynamic registration, such as
+Gemini Enterprise, get a client ID and secret through the `MCP_OAUTH_CLIENTS`
+secret, with their callback in `redirect_uris` (for Gemini Enterprise,
+`https://vertexaisearch.cloud.google.com/oauth-redirect`).
+
+`PROMPT.md` is the prompt for coding agents working with Tavus through this
+server. Paste it into Claude Code, Codex or Cursor: it gets the client
+connected, asks what the user wants to build, and states the contracts for
+building, changing and testing a PAL and wiring its tools into the user's code.
+Put a known PAL id or tool list above it and the agent will not ask for them.
+When the user wants the PAL in front of people, the agent suggests a landing
+page, embed or widget from the project, creates the deployment with
+`tavus_deployment_create`, and either shares the landing page link or hands
+off to the embed or widget prompt in tavus-examples
+(`examples/embed-prompt.md`, `examples/widget-prompt.md`) with the
+deployment id and the PAL's page tools already filled in.
 
 ### ChatGPT plugin
 
@@ -148,6 +168,7 @@ Command groups:
 | `tavus guardrail`, `tavus objective`, `tavus tool`, `tavus pronunciation-dictionary` | CRUD for each resource |
 | `tavus face`, `tavus resource`, `tavus skill` | account resource discovery |
 | `tavus conversation` | create or end CVI conversations |
+| `tavus deployment` | `list`, `get`, `create` — put a PAL on a landing page, an embed or a widget |
 | `tavus auth`, `tavus doctor`, `tavus quickstart`, `tavus embed` | login, environment checks, one-call PAL + conversation, embed scaffolding |
 
 Examples:

tavus_cli-0.8.0/PROMPT.md

@@ -0,0 +1,65 @@
+You are working with Tavus from this coding session through the Tavus MCP server: building and changing PALs (Tavus's AI personas that hold real-time, face-to-face video conversations), giving them tools that act in my app, and testing them. The server is hosted at `https://mcp.tavus.io/mcp` and exposes `tavus_*` tools that read and write my Tavus account. The tools return data and file manifests; they never write files. You write any code into my repo yourself.
+
+Before anything else, check that the `tavus_*` tools are available to you. If they are not, give me the one setup step for my client and stop until I have done it:
+
+- Claude Code: `claude mcp add -s user --transport http tavus https://mcp.tavus.io/mcp`
+- Codex: `codex mcp add tavus --url https://mcp.tavus.io/mcp`, then `codex mcp login tavus`
+- Cursor and other MCP clients: add `https://mcp.tavus.io/mcp` as a remote (HTTP) MCP server named `tavus`
+- Claude.ai and ChatGPT: add a custom connector with the same URL
+
+Sign-in happens in the browser on first use, with my Tavus account. Some clients need a restart before new tools show up. Once the tools are there, call `tavus_mcp_health_check` and continue only when it passes.
+
+Then read the reference pages below (the `.md` URLs return plain markdown) and ask me these things:
+
+1. What we are doing. One of these, a mix, or something else entirely:
+   (a) build a new PAL from my description,
+   (b) change a PAL I already have (its prompt, greeting, objectives, guardrails, knowledge, capabilities, face or voice),
+   (c) give a PAL tools that act in my app or call my backend, and write the code in this repo that handles them,
+   (d) test a PAL by text against specific questions,
+   (e) put a PAL in front of people: inside this app, on my website, or as a link I can share,
+   (f) your own idea, described in your words.
+   If I am not sure what to build, look at this repo, then suggest what fits and say why.
+2. Which PAL, for anything other than a new one, unless its id is already given above this prompt or came from a build earlier in this session; then use it and do not ask. If I do not know the id, list my PALs with `tavus_pal_list` and `sort: "desc"` (newest first) and let me pick. Do not invent an id.
+3. For tools, unless they are already listed above this prompt: what each one should do, and whether it runs on the page (in the browser, next to the conversation) or on my backend (a URL Tavus calls). Look at this repo before asking, since the answer is often in the code.
+
+How the server works
+
+- One account, production. The hosted server acts on the Tavus account I signed in with, against the production API. There is no environment switch and no API key in the client config.
+- Everything on a PAL is a resource with an id: faces, voices, guardrails, objectives, Knowledge documents, tools. Get ids from the matching list call (`tavus_face_list`, `tavus_voice_list`, `tavus_guardrail_list`, `tavus_objective_list`, `tavus_document_list`, `tavus_tool_list`) or from `tavus_describe_pal_options`, which returns one PAL with everything attachable to it.
+- Tools are first-class records. A tool is created once with `tavus_tool_create` and attached with `tavus_pal_tools_attach`. Writing tools inline under `layers.llm.tools` is rejected.
+- The five PAL Maker capabilities (Magic Canvas, Slide Presenter, Web Search, Perception, Memory) go through `tavus_pal_capability_attach`, `tavus_pal_capability_patch` and `tavus_pal_capability_detach`, not raw patches.
+- Every conversation is billed like any other, including the build's own test turns, chat-mode tests and previews.
+
+How to do the common things properly
+
+These are the contracts the server keeps. Exact parameters and response shapes are in the reference below; the order of operations is here, because that is what tends to get invented.
+
+- Building a new PAL. Use `tavus_pal_build_and_verify`; it is the standard path. You run the interview first: ask me plain questions, up to 12, about who the PAL talks to, what a good conversation achieves, the tone, what it must never say or do, what it should know (links to documents), and what it should do in my app. Ask only what my description leaves open. Pass my description as `prompt`, the questions and my answers as `interview`, and your summary of each part as `briefs`. The call takes one to three minutes. It drafts the personality, objectives, guardrails and greeting, picks a face unless I asked for one (`face_id`), publishes the PAL, runs test conversations and judges them. Read `verdict.overall` (`pass`, `partial` or `fail`), then the summary and any failing evidence, before you tell me it works. Tools can only be attached once the PAL exists, so the build's test turns run without them and tool checks in the verdict fail; attach the tools, then rerun those turns with chat mode before you tell me the tools work. Give me the `pal_url` it returns; that opens the PAL in the PAL Maker. Use `tavus_pal_create` or `tavus_quickstart` only when I hand you a finished system prompt and ask you to skip the build.
+- Changing an existing PAL. Call `tavus_pal_get` and `tavus_describe_pal_options` first, and take ids and patch paths from what they return. Make the smallest change with `tavus_patch_pal` (JSON Patch operations such as `replace` on `/greeting`), or use the dedicated tools for capabilities, Knowledge and tools. A change applies to every conversation the PAL starts from then on, including on my live site, so tell me what will change and get a yes before patching a PAL that is already in use.
+- Giving the PAL a tool. Check `tavus_tool_list` first and attach an existing tool when its name, parameters and delivery fit. When you create a new one that overlaps an existing tool, tell me which tool you saw and why it does not fit. The tool's `description` is what tells the PAL when to call it, so write it as an instruction. `delivery` decides where the call goes: `{ "app_message": true }` (the default) sends it to the page running the conversation, and `delivery.api` makes Tavus call a backend URL. Then write the handler in this repo with the exact tool name and parameter schema, so the two halves match. On a page that uses `<tavus-embed>` or `<tavus-widget>`, the call arrives as `tavus:tool-call` `{ name, arguments, tool_call_id }` with `arguments` as a JSON string, and the page replies with `sendMessage({ event_type: "conversation.tool_result", properties: { tool_call_id, output, status: "success" } })`; the host communication page below has the full contract. A tool that is not attached to the PAL never fires, however the code is wired.
+- Giving the PAL knowledge. Create a Knowledge document from a URL anyone can reach with `tavus_document_create`, then attach it with `tavus_pal_knowledge_add`. The hosted server cannot read files on my machine; for a local file, ask me to upload it in the PAL Maker's Knowledge section or to host it at a URL. Before you tell me what a document says, read what Tavus indexed with `tavus_document_chunks`.
+- Testing by text. `tavus_chat_start` starts a text-only conversation with the PAL, `tavus_chat_turn` sends one message and waits for the reply, and `tavus_chat_end` ends it. Always end the conversations you start. The first turn is slower while the conversation starts up. Replies are not deterministic, so judge behaviour (did it ask for the order number, did it refuse the pricing promise) rather than exact wording.
+- Seeing it on video. `tavus_pal_preview` starts a full video conversation and returns its URL for me to open. Do it after the text tests pass, and only when I want to see or hear the PAL.
+- Putting the PAL in front of people. A deployment is what makes a PAL reachable, and there are three kinds. A landing page is a page Tavus hosts, with its own link, for when there is no site in this repo or I want something to send around. Embed puts the conversation inside a page of my app: a section, a card, a step in a flow. Widget is a floating launcher on every page of my site. Pick one from what this repo is, propose it with a reason, and let me decide. If I want the PAL to act on the page (open a product, fill a form), create and attach those tools before deploying, so the handoff below includes them.
+- Creating the deployment. Call `tavus_deployment_list` with the PAL id first and offer to reuse a deployment that already fits. Otherwise ask me what `tavus_deployment_create` needs: whether each visitor gets their own memory of past calls; for embed or widget, where the site is hosted, as origins such as `https://www.example.com`, plus `http://localhost:<port>` from this repo's dev server if I want to try it locally (an empty list lets any site load it); for a landing page, a headline and one sentence you draft from what the PAL does; and how much use to allow, since every call is billed and a deployment has no limits unless I set them: calls per day across all visitors, calls per day per visitor, calls at the same moment, and the longest a call may last. Suggest numbers that fit what I am building, and let me say no limit. A deployment is live and public as soon as it is created, so show me these values and get a yes first.
+- Handing off. `tavus_deployment_create` returns an `integration` block. For a landing page, give me `landing_page_url`. For embed or widget, read `prompt_url` and follow that prompt with `prompt_header` placed above it, so it does not ask for the deployment id or the page tools again; write a handler for every entry in `page_tools`, reusing any handler you already wrote in this session. When the PAL's tools change later, `tavus_deployment_get` returns the current list. Changing a deployment's settings or taking it down happens in the [Tavus PAL Maker](https://maker.tavus.io). Do not use `tavus_scaffold_embed` for a site: it wraps the URL of a single conversation, which stops working when that conversation ends.
+
+Not possible, not needed, or not yours to do
+
+- Do not ask me for an API key, and do not put one in the MCP config, an env file or the chat. Sign-in is the browser flow above.
+- Changing or taking down a deployment, billing, team members and account settings are not available through the MCP server. Send me to the PAL Maker or the developer portal for those.
+- Do not invent ids for PALs, faces, voices, guardrails, objectives, documents or tools. Every id comes from a list or get call.
+- Do not delete PALs, tools, guardrails, objectives, documents or pronunciation dictionaries, and do not end conversations you did not start, unless I ask for that exact action.
+- Do not retry a failed write in a loop. Read the error; if it looks like sign-in or connectivity, call `tavus_mcp_health_check` and tell me what it says.
+- Tool names and parameters are exactly what the server lists. If a tool is not in your tool list, it does not exist.
+
+Reference, current and authoritative; this prompt is not a substitute for it:
+
+- Connecting a client, tool delivery to the page or a backend: https://docs.tavus.io/sections/agent-tools/mcp-server.md
+- Every MCP tool and its parameters: https://docs.tavus.io/sections/agent-tools/mcp-tools-reference.md
+- The guided build and how to read its verdict: https://docs.tavus.io/sections/agent-tools/pal-build-and-verify.md
+- Handling tool calls on a page with `<tavus-embed>` or `<tavus-widget>`: https://docs.tavus.io/sections/deployments/host-communication.md
+- Coding-agent prompt for `<tavus-embed>`: https://raw.githubusercontent.com/Tavus-Engineering/tavus-examples/main/examples/embed-prompt.md
+- Coding-agent prompt for `<tavus-widget>`: https://raw.githubusercontent.com/Tavus-Engineering/tavus-examples/main/examples/widget-prompt.md
+- Deployments: https://docs.tavus.io/sections/deployments/landing-page.md, https://docs.tavus.io/sections/deployments/embed.md and https://docs.tavus.io/sections/deployments/widget.md
+- Full documentation index: https://docs.tavus.io/llms.txt

{tavus_cli-0.7.0 → tavus_cli-0.8.0}/README.md

@@ -7,8 +7,9 @@ MCP-aware client) drive the same platform through the API:
 - **MCP server.** The full PAL surface as MCP tools: the guided build
   (`tavus_pal_build_and_verify`), chat-mode text testing, and CRUD for PALs,
   tools, knowledge, guardrails, objectives, pronunciation dictionaries,
-  capabilities, faces, and voices. Run it locally over stdio, or connect to
-  the hosted server at `https://mcp.tavus.io/mcp`.
+  capabilities, faces, and voices, plus deployments that put a PAL on a
+  landing page, an embed or a widget. Run it locally over stdio, or connect
+  to the hosted server at `https://mcp.tavus.io/mcp`.
 - **`tavus` CLI.** The same surface as shell commands, published to PyPI as
   [`tavus-cli`](https://pypi.org/project/tavus-cli/). Scripted PAL authoring
   and publishing, JSON round-tripping, browser login with OS-keychain storage.
@@ -34,9 +35,28 @@ OAuth metadata and dynamic client registration, so the client sends you
 through Tavus browser sign-in. The developer portal mints a per-user API key;
 the Worker keeps it encrypted server-side and issues expiring OAuth tokens.
 The API key never appears in client configuration or browser callback URLs.
-Claude and ChatGPT callback
-URLs are accepted automatically; other hosted clients must be registered
-through `MCP_OAUTH_CLIENTS`.
+
+Dynamic client registration accepts loopback callbacks from any local client
+(Claude Code, Codex, Gemini CLI) and the hosted callbacks of Claude, ChatGPT,
+Cursor, VS Code, v0, Lovable and Replit. They are listed in `KNOWN_REMOTE_CLIENTS` in
+`workers/tavus-mcp/src/oauth.ts`. To add a client, press Connect in it once,
+read its callback from the Worker's `oauth_register_rejected` log line, and add
+an entry with a test. Clients that don't use dynamic registration, such as
+Gemini Enterprise, get a client ID and secret through the `MCP_OAUTH_CLIENTS`
+secret, with their callback in `redirect_uris` (for Gemini Enterprise,
+`https://vertexaisearch.cloud.google.com/oauth-redirect`).
+
+`PROMPT.md` is the prompt for coding agents working with Tavus through this
+server. Paste it into Claude Code, Codex or Cursor: it gets the client
+connected, asks what the user wants to build, and states the contracts for
+building, changing and testing a PAL and wiring its tools into the user's code.
+Put a known PAL id or tool list above it and the agent will not ask for them.
+When the user wants the PAL in front of people, the agent suggests a landing
+page, embed or widget from the project, creates the deployment with
+`tavus_deployment_create`, and either shares the landing page link or hands
+off to the embed or widget prompt in tavus-examples
+(`examples/embed-prompt.md`, `examples/widget-prompt.md`) with the
+deployment id and the PAL's page tools already filled in.
 
 ### ChatGPT plugin
 
@@ -126,6 +146,7 @@ Command groups:
 | `tavus guardrail`, `tavus objective`, `tavus tool`, `tavus pronunciation-dictionary` | CRUD for each resource |
 | `tavus face`, `tavus resource`, `tavus skill` | account resource discovery |
 | `tavus conversation` | create or end CVI conversations |
+| `tavus deployment` | `list`, `get`, `create` — put a PAL on a landing page, an embed or a widget |
 | `tavus auth`, `tavus doctor`, `tavus quickstart`, `tavus embed` | login, environment checks, one-call PAL + conversation, embed scaffolding |
 
 Examples:

{tavus_cli-0.7.0 → tavus_cli-0.8.0}/docs/gemini-enterprise/test-queries.md

@@ -10,7 +10,7 @@ Each test-env Tavus account is pre-seeded with at least:
 - 3 pals (`customer-support-demo`, `interviewer-demo`, `tutor-demo`)
 - 5 system faces
 - 2 documents
-- 1 guardrail set
+- 1 guardrail
 - 1 objective tree
 
 Credentials and exact pal/face IDs are delivered out-of-band per

{tavus_cli-0.7.0 → tavus_cli-0.8.0}/packages/tavus/pyproject.toml

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

{tavus_cli-0.7.0 → tavus_cli-0.8.0}/packages/tavus-mcp/pyproject.toml

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

{tavus_cli-0.7.0 → tavus_cli-0.8.0}/pyproject.toml

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

{tavus_cli-0.7.0 → tavus_cli-0.8.0}/skills/tavus-agentic-pals/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: tavus-agentic-pals
-description: Use when Codex needs to create, inspect, edit, test, or embed Tavus pals with the tavus CLI or tavus-mcp MCP server. Covers the guided PAL Maker build (tavus_pal_build_and_verify / tavus pal build), chat-mode text testing, local TEST/STG/PROD environment selection, dev-portal login, API-key storage, safe pal patching, account resource discovery, conversation creation, embed scaffolding, and CLI/MCP examples.
+description: Use when Codex needs to create, inspect, edit, test, or embed Tavus pals with the tavus CLI or tavus-mcp MCP server. Covers the guided PAL Maker build (tavus_pal_build_and_verify / tavus pal build), chat-mode text testing, local TEST/STG/PROD environment selection, dev-portal login, API-key storage, safe pal patching, account resource discovery, conversation creation, deployments to a landing page, embed or widget, embed scaffolding, and CLI/MCP examples.
 ---
 
 # Tavus Agentic PALs
@@ -142,7 +142,15 @@ Conversation and resource tools:
 - `tavus_resource_list(resource, limit)` for `guardrails`, `objectives`, `documents`, `voices`, `skills`, or `tools`
 - `tavus_scaffold_embed(conversation_url, target, component_name)`
 
-`tavus_scaffold_embed` returns a file manifest. The MCP host agent writes files if the user wants files created.
+`tavus_scaffold_embed` returns a file manifest. The MCP host agent writes files if the user wants files created. It wraps one conversation URL; use a deployment to put a PAL on a site.
+
+Deployment tools (a PAL on a landing page, an embed or a widget):
+
+- `tavus_deployment_list(pal_id?, channel?, status?, limit?, page?)` — newest first; check it before creating so an existing deployment gets reused
+- `tavus_deployment_get(deployment_id)` — the deployment plus its `integration` block, with the PAL's current page tools
+- `tavus_deployment_create(pal_id, channel, unique_memory_per_visitor, allowed_origins?, page_title?, page_description?, page_cta?, page_logo?, name?, context?, daily_call_limit?, daily_call_limit_per_user?, concurrent_call_limit?, max_call_duration?)` — creates an active deployment. `channel` is `landing-page`, `embed` or `widget`. Ask the user about memory per visitor and the limits (no limit unless set; `max_call_duration` is in seconds); embed and widget need `allowed_origins` (where the site is hosted, `[]` for any site); a landing page needs `page_title` and `page_description`. It is public at once, so confirm the values first.
+
+The `integration` block holds `landing_page_url` for a landing page. For an embed or widget it holds the snippet, `prompt_url` (the tavus-examples coding-agent prompt), `prompt_header` (the deployment id and page-tool lines that go above that prompt) and `page_tools` (every attached tool with `delivery.app_message`). Changing or taking down a deployment happens in the PAL Maker.
 
 Guardrail resources (attach via `/guardrail_ids` or `/guardrail_tags`):
 
@@ -248,11 +256,11 @@ Prefer focused patches over full rebuilds:
 [
   {"op": "replace", "path": "/pal_name", "value": "Support Concierge v2"},
   {"op": "replace", "path": "/layers/conversational_flow/active_listening", "value": true},
-  {"op": "replace", "path": "/guardrails_id", "value": "grd_123"}
+  {"op": "replace", "path": "/guardrail_ids", "value": ["grd_123", "grd_456"]}
 ]
 ```
 
-Common patch targets include `/system_prompt`, `/greeting`, `/context`, `/pal_name`, `/default_face_id`, `/objectives_id`, `/guardrails_id`, `/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`.
+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`.
 
 ## Creation Patterns
 

{tavus_cli-0.7.0 → tavus_cli-0.8.0}/src/tavus_mcp/__init__.py

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

{tavus_cli-0.7.0 → tavus_cli-0.8.0}/src/tavus_mcp/cli/main.py

@@ -27,6 +27,11 @@ from tavus_mcp.sdk.recipes.capabilities import (
     list_pal_capabilities,
     patch_pal_capability,
 )
+from tavus_mcp.sdk.recipes.deployments import (
+    compact_deployment_list,
+    create_deployment,
+    get_deployment,
+)
 from tavus_mcp.sdk.recipes.knowledge import (
     add_pal_knowledge,
     list_pal_knowledge,
@@ -38,6 +43,7 @@ from tavus_mcp.sdk.recipes.knowledge import (
 from tavus_mcp.sdk.recipes.options import describe_pal_options
 from tavus_mcp.sdk.recipes.quickstart import quickstart as quickstart_recipe
 from tavus_mcp.sdk.recipes.scaffold_embed import scaffold_embed
+from tavus_mcp.sdk.schemas.deployment import DEPLOYMENT_CREATE_ADAPTER
 
 HELP_CONTEXT = {"help_option_names": ["-h", "--help"]}
 
@@ -59,6 +65,7 @@ document_app = typer.Typer(no_args_is_help=True, context_settings=HELP_CONTEXT)
 skill_app = typer.Typer(no_args_is_help=True, context_settings=HELP_CONTEXT)
 builder_app = typer.Typer(no_args_is_help=True, context_settings=HELP_CONTEXT)
 chat_app = typer.Typer(no_args_is_help=True, context_settings=HELP_CONTEXT)
+deployment_app = typer.Typer(no_args_is_help=True, context_settings=HELP_CONTEXT)
 app.add_typer(auth_app, name="auth")
 app.add_typer(pal_app, name="pal")
 pal_app.add_typer(pal_tools_app, name="tools")
@@ -76,6 +83,7 @@ app.add_typer(skill_app, name="skill")
 app.add_typer(pronunciation_app, name="pronunciation-dictionary")
 app.add_typer(builder_app, name="builder")
 app.add_typer(chat_app, name="chat")
+app.add_typer(deployment_app, name="deployment")
 console = Console()
 
 
@@ -274,14 +282,11 @@ def pal_create(
         None, "--memory", help="Initial seed memory. Repeat for multiple."
     ),
     objectives_id: str | None = typer.Option(None, "--objectives-id"),
-    guardrails_id: str | None = typer.Option(
-        None, "--guardrails-id", help="Legacy guardrail-set id."
-    ),
     guardrail_ids: list[str] | None = typer.Option(
-        None, "--guardrail-id", help="Repeat for multiple. New flat shape."
+        None, "--guardrail-id", help="Attach a flat guardrail by id. Repeat for multiple."
     ),
     guardrail_tags: list[str] | None = typer.Option(
-        None, "--guardrail-tag", help="Repeat for multiple. New flat shape."
+        None, "--guardrail-tag", help="Attach flat guardrails by tag. Repeat for multiple."
     ),
     document_ids: list[str] | None = typer.Option(
         None, "--document-id", help="Repeat for multiple."
@@ -320,8 +325,6 @@ def pal_create(
                 body["memories"] = list(memories)
             if objectives_id:
                 body["objectives_id"] = objectives_id
-            if guardrails_id:
-                body["guardrails_id"] = guardrails_id
             if guardrail_ids:
                 body["guardrail_ids"] = list(guardrail_ids)
             if guardrail_tags:
@@ -1187,7 +1190,11 @@ def guardrail_list(
     type: str = typer.Option("user", help="user | system | all"),
     name_or_uuid: str | None = typer.Option(None),
     tags: str | None = typer.Option(None, help="Comma-separated tag filter."),
-    legacy: bool = typer.Option(False, help="Return the legacy set-shape list."),
+    legacy: bool = typer.Option(
+        False,
+        help="Read-only: surface older grouped-shape rows. Off by default; "
+        "this SDK works with flat, per-rule guardrails.",
+    ),
     verbose: bool = typer.Option(False, help="Include persona_refs + guardrail_type."),
     json_output: bool = typer.Option(False, "--json"),
 ) -> None:
@@ -2031,6 +2038,115 @@ def _resource(client: TavusClient, resource: str) -> Any:
     return getattr(client, attr)
 
 
+@deployment_app.command("list")
+def deployment_list(
+    pal_id: str | None = typer.Option(None, "--pal-id"),
+    channel: str | None = typer.Option(None, help="landing-page | embed | widget"),
+    status: str | None = typer.Option(None, help="draft | active | inactive"),
+    limit: int = typer.Option(25),
+    page: int = typer.Option(0),
+    json_output: bool = typer.Option(False, "--json"),
+) -> None:
+    """List deployments, newest first."""
+
+    async def run() -> Any:
+        async with TavusClient.from_env(surface="cli") as client:
+            return await client.deployments.list(
+                pal_id=pal_id,
+                channel=channel,
+                status=status,
+                limit=limit,
+                page=page,
+                include_thumbnails="false",
+            )
+
+    data = compact_deployment_list(_run(run()))
+    if json_output:
+        _json(data)
+        return
+    _print_rows(data, ["deployment_id", "name", "channel", "status", "pal_id", "updated_at"])
+
+
+@deployment_app.command("get")
+def deployment_get(deployment_id: str) -> None:
+    """Show a deployment with its landing page link, or its snippet and page tools."""
+
+    async def run() -> Any:
+        async with TavusClient.from_env(surface="cli") as client:
+            return await get_deployment(client, deployment_id)
+
+    _json(_run(run()))
+
+
+@deployment_app.command("create")
+def deployment_create(
+    pal_id: str = typer.Option(..., "--pal-id"),
+    channel: str = typer.Option(..., help="landing-page | embed | widget"),
+    unique_memory_per_visitor: bool = typer.Option(
+        ...,
+        "--memory-per-visitor/--shared-memory",
+        help="Give each visitor their own memory of past calls, or share one across visitors.",
+    ),
+    allowed_origins: list[str] | None = typer.Option(
+        None,
+        "--allowed-origin",
+        help="Site allowed to load an embed or widget, such as https://www.example.com. "
+        "Repeat for more. Required for embed and widget; pass --any-origin to allow any site.",
+    ),
+    any_origin: bool = typer.Option(False, "--any-origin", help="Let any site load it."),
+    page_title: str | None = typer.Option(
+        None, help="Landing page headline. Required for a landing page."
+    ),
+    page_description: str | None = typer.Option(
+        None, help="Sentence under the headline. Required for a landing page."
+    ),
+    page_logo: str | None = typer.Option(None, help="Landing page logo image URL."),
+    name: str | None = typer.Option(
+        None, help='Defaults to "<PAL name> Link", "Embed" or "Widget".'
+    ),
+    context: str | None = typer.Option(
+        None, help="What every call from this deployment should know."
+    ),
+    daily_call_limit: int | None = typer.Option(None, help="Calls per day across all visitors."),
+    daily_call_limit_per_user: int | None = typer.Option(None, help="Calls per day per visitor."),
+    concurrent_call_limit: int | None = typer.Option(None, help="Calls at the same moment."),
+    max_call_duration: int | None = typer.Option(None, help="Length of one call, in seconds."),
+) -> None:
+    """Create a live deployment. It is public as soon as it exists. Calls are
+    unlimited unless you set the limit options."""
+
+    async def run() -> Any:
+        fields: dict[str, Any] = {
+            "pal_id": pal_id,
+            "channel": channel,
+            "unique_memory_per_visitor": unique_memory_per_visitor,
+            "allowed_origins": [] if any_origin else allowed_origins,
+            "page_title": page_title,
+            "page_description": page_description,
+            "page_logo": page_logo,
+            "name": name,
+            "context": context,
+            "limits": {
+                key: value
+                for key, value in {
+                    "daily_call_limit": daily_call_limit,
+                    "daily_call_limit_per_user": daily_call_limit_per_user,
+                    "concurrent_call_limit": concurrent_call_limit,
+                    "max_call_duration": max_call_duration,
+                }.items()
+                if value is not None
+            }
+            or None,
+        }
+        request = DEPLOYMENT_CREATE_ADAPTER.validate_python(
+            {key: value for key, value in fields.items() if value is not None}
+        )
+        async with TavusClient.from_env(surface="cli") as client:
+            return await create_deployment(client, request)
+
+    _json(_run(run()))
+
+
 def _print_rows(data: Any, columns: list[str]) -> None:
     rows = data.get("data", data) if isinstance(data, dict) else data
     if not isinstance(rows, list):

{tavus_cli-0.7.0 → tavus_cli-0.8.0}/src/tavus_mcp/sdk/client/http.py

@@ -140,6 +140,7 @@ class TavusClient:
         self.tools = ToolResource(self)
         self.pronunciation_dictionaries = PronunciationDictionaryResource(self)
         self.builders = BuilderResource(self)
+        self.deployments = Resource(self, "deployments")
 
     @classmethod
     def from_env(
@@ -477,8 +478,8 @@ class PalResource(Resource):
 
 
 class GuardrailResource(Resource):
-    """Flat-list guardrails (no more sets). Adds `validate` and `tags` to the
-    base CRUD surface."""
+    """Flat-list guardrails (no more sets). Adds `tags` to the base CRUD
+    surface."""
 
     def __init__(self, client: TavusClient) -> None:
         super().__init__(client, "guardrails")
@@ -491,11 +492,6 @@ class GuardrailResource(Resource):
         validated = GuardrailUpdate.model_validate(payload).model_dump(exclude_none=True)
         return await self.client.request("PATCH", f"/guardrails/{resource_id}", json=validated)
 
-    async def validate(self, payload: dict[str, Any]) -> Any:
-        """`POST /v2/guardrails/validate` — checks a legacy set-shape payload
-        without persisting. Useful before bulk-importing."""
-        return await self.client.request("POST", "/guardrails/validate", json=payload)
-
     async def tags(self, **params: Any) -> Any:
         """`GET /v2/guardrails/tags` — KB-shaped `{tags, total_count}`."""
         return await self.client.request("GET", "/guardrails/tags", params=_clean(params))