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

tavus_cli-0.8.0/.agents/plugins/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "tavus",
+  "interface": { "displayName": "Tavus" },
+  "plugins": [
+    {
+      "name": "tavus-pal",
+      "source": { "source": "local", "path": "./plugins/tavus-pal" },
+      "policy": { "installation": "AVAILABLE", "authentication": "ON_INSTALL" },
+      "category": "Developer Tools"
+    }
+  ]
+}

{tavus_cli-0.6.0 → tavus_cli-0.8.0}/.github/workflows/ci.yml

@@ -41,6 +41,15 @@ jobs:
         run: uv run pytest -q
       - name: Build
         run: uv build
+      - name: Build ChatGPT plugin package
+        run: python scripts/build_chatgpt_plugin.py
+      - name: Upload ChatGPT plugin package
+        if: matrix.python-version == '3.13'
+        uses: actions/upload-artifact@v4
+        with:
+          name: tavus-pal-plugin
+          path: dist/tavus-pal-*.zip
+          if-no-files-found: error
 
   worker:
     runs-on: ubuntu-latest

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

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

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

@@ -1,5 +1,35 @@
 # 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)
+
+
+### Features
+
+* package Tavus PAL plugin with delegated OAuth sessions ([#53](https://github.com/Tavus-Engineering/tavus-mcp/issues/53)) ([8479143](https://github.com/Tavus-Engineering/tavus-mcp/commit/8479143bc05a1e4016ae9cfdc1359aebaf69714e))
+
+
+### Bug Fixes
+
+* keep hosted MCP connections signed in ([#57](https://github.com/Tavus-Engineering/tavus-mcp/issues/57)) ([02e5eee](https://github.com/Tavus-Engineering/tavus-mcp/commit/02e5eee8992f8f77423d454469127456cd2a74ee))
+
 ## [0.6.0](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.5.0...v0.6.0) (2026-10-07)
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tavus-cli
-Version: 0.6.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.
@@ -53,10 +54,45 @@ claude mcp add -s user --transport http tavus https://mcp.tavus.io/mcp
 Claude.ai and ChatGPT custom connectors use the same URL. Do not put a Tavus
 API key or shared bearer token in client config: the Worker exposes standard
 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
-that stays server-side, scoped to your account. Claude and ChatGPT callback
-URLs are accepted automatically; other hosted clients must be registered
-through `MCP_OAUTH_CLIENTS`.
+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.
+
+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
+
+`plugins/tavus-pal/` packages this same hosted server as **Tavus PAL** for
+ChatGPT and Codex. It adds listing metadata and Tavus icons; tools and account
+authorization continue to live in the Worker. Build the uploadable ZIP with:
+
+```bash
+python scripts/build_chatgpt_plugin.py
+```
+
+The repository marketplace is `.agents/plugins/marketplace.json`. See
+[ChatGPT setup and release guide](docs/chatgpt-plugin.md) for installation,
+authentication, migration, and directory submission.
 
 ## Local MCP server
 
@@ -132,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:
@@ -265,12 +302,20 @@ The authorize step redirects to the developer portal at
 `/dev/cli-authorize?mode=oauth`. The portal verifies the Worker's signed
 request, shows the connector destination, and after sign-in posts a per-user
 API key to the Worker's trusted `/oauth/callback`. The Worker issues an
-opaque, short-lived authorization code, verifies PKCE plus the client,
-redirect, and MCP resource at `/token`, then forwards the resulting bearer to
-the Tavus API as `x-api-key`. A SQLite-backed Durable Object makes both the
-authorization request and the code one-time to prevent replay. Tavus API keys
-stay user-scoped and never appear in MCP client configuration or browser
-callback URLs.
+short-lived authorization code, verifies PKCE plus the registered client,
+redirect, and MCP resource at `/token`, and issues a 15-minute opaque access
+token and rotating refresh token. The account API key stays encrypted in a
+SQLite-backed Durable Object; only token hashes are stored. Each MCP request
+validates the token's resource, scope, and expiry before using the linked key.
+Authorization requests and codes remain one-time grants.
+
+Sessions do not expire. A session ends when `POST /revoke` revokes it, or when
+a refresh token is reused more than 60 seconds after its first use. A reuse
+within 60 seconds, such as a retry or two concurrent refreshes, gets new tokens.
+A Tavus API key sent directly as the bearer token still works, so connections
+made before OAuth sessions existed keep working. Native CLI sign-in is
+unchanged. See [migration and rollout](docs/chatgpt-plugin.md#authentication-and-rollout)
+before deploying.
 
 ### Local and hosted parity
 

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.6.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.
@@ -31,10 +32,45 @@ claude mcp add -s user --transport http tavus https://mcp.tavus.io/mcp
 Claude.ai and ChatGPT custom connectors use the same URL. Do not put a Tavus
 API key or shared bearer token in client config: the Worker exposes standard
 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
-that stays server-side, scoped to your account. Claude and ChatGPT callback
-URLs are accepted automatically; other hosted clients must be registered
-through `MCP_OAUTH_CLIENTS`.
+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.
+
+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
+
+`plugins/tavus-pal/` packages this same hosted server as **Tavus PAL** for
+ChatGPT and Codex. It adds listing metadata and Tavus icons; tools and account
+authorization continue to live in the Worker. Build the uploadable ZIP with:
+
+```bash
+python scripts/build_chatgpt_plugin.py
+```
+
+The repository marketplace is `.agents/plugins/marketplace.json`. See
+[ChatGPT setup and release guide](docs/chatgpt-plugin.md) for installation,
+authentication, migration, and directory submission.
 
 ## Local MCP server
 
@@ -110,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:
@@ -243,12 +280,20 @@ The authorize step redirects to the developer portal at
 `/dev/cli-authorize?mode=oauth`. The portal verifies the Worker's signed
 request, shows the connector destination, and after sign-in posts a per-user
 API key to the Worker's trusted `/oauth/callback`. The Worker issues an
-opaque, short-lived authorization code, verifies PKCE plus the client,
-redirect, and MCP resource at `/token`, then forwards the resulting bearer to
-the Tavus API as `x-api-key`. A SQLite-backed Durable Object makes both the
-authorization request and the code one-time to prevent replay. Tavus API keys
-stay user-scoped and never appear in MCP client configuration or browser
-callback URLs.
+short-lived authorization code, verifies PKCE plus the registered client,
+redirect, and MCP resource at `/token`, and issues a 15-minute opaque access
+token and rotating refresh token. The account API key stays encrypted in a
+SQLite-backed Durable Object; only token hashes are stored. Each MCP request
+validates the token's resource, scope, and expiry before using the linked key.
+Authorization requests and codes remain one-time grants.
+
+Sessions do not expire. A session ends when `POST /revoke` revokes it, or when
+a refresh token is reused more than 60 seconds after its first use. A reuse
+within 60 seconds, such as a retry or two concurrent refreshes, gets new tokens.
+A Tavus API key sent directly as the bearer token still works, so connections
+made before OAuth sessions existed keep working. Native CLI sign-in is
+unchanged. See [migration and rollout](docs/chatgpt-plugin.md#authentication-and-rollout)
+before deploying.
 
 ### Local and hosted parity
 

tavus_cli-0.8.0/docs/chatgpt-plugin.md

@@ -0,0 +1,165 @@
+# Tavus PAL for ChatGPT
+
+Tavus PAL packages the existing hosted MCP server for ChatGPT and Codex.
+It uses `https://mcp.tavus.io/mcp` directly, so every hosted tool keeps its
+existing implementation, schema, account, and API behavior. There is no
+second server or copied tool registry to maintain.
+
+## Build and install
+
+```bash
+python scripts/build_chatgpt_plugin.py
+```
+
+This produces `dist/tavus-pal-0.1.0.zip`. The ZIP contains only `plugin.json`,
+`mcp.json`, and two square SVG icons derived from the portal's Tavus favicon.
+No account credentials, local environment files, or test evidence are bundled.
+The portable Agent Plugins schemas validate both manifests. The package has
+its own version because listing changes do not require an MCP server release.
+
+For local distribution, the repository's `.agents/plugins/marketplace.json`
+points to `plugins/tavus-pal`. Add the repository root as a local marketplace
+in a supported ChatGPT/Codex desktop client, then install Tavus PAL from that
+source. Account linking still uses Tavus OAuth.
+
+For a browser-only test, open ChatGPT Plugins, add a custom MCP server with
+the URL above, choose OAuth with dynamic client registration (DCR), and complete
+Tavus sign-in. Do not enter API keys in a prompt or plugin configuration.
+If a Tavus connection already exists, refresh its tools before testing.
+
+For directory distribution, upload the ZIP to the OpenAI Plugins dashboard
+under the verified Tavus publishing identity. A package upload is a draft;
+review approval and publication are separate steps. Reuse an existing Tavus
+listing when appropriate rather than creating a duplicate.
+
+## What the plugin supports
+
+The current hosted server exposes 67 tools. It can create and edit PALs,
+choose available faces and voices, attach knowledge and capabilities, configure
+guardrails and objectives, run text conversations, and return a browser video
+preview URL. The guided build tool drafts and publishes a PAL and evaluates
+conversation probes. Creation, building, and conversations use the connected
+Tavus account's existing entitlements and may consume Tavus usage.
+
+This is a conversational digital-human integration. The hosted tool set does
+not include custom face/replica training, asynchronous rendered-video generation,
+PAL marketplace listings, purchase, or ownership transfer. Hosted MCP also
+cannot read local file paths; Python-only upload and builder-administration
+tools remain the documented parity exceptions.
+
+The package does not add an embedded video widget. Video preview opens the
+Tavus conversation URL, matching existing MCP behavior. OpenAI supports optional
+MCP UI, but microphone/camera behavior in an embedded Tavus call still needs
+separate implementation and host testing before promising an in-chat video call.
+
+## Authentication and rollout
+
+The Worker owns OAuth discovery, dynamic client registration, PKCE S256,
+signed authorization requests, and single-use codes. The portal's existing
+`/dev/cli-authorize?mode=oauth` flow signs the user in, obtains consent, and
+posts an account API key to the trusted Worker callback. No portal or public
+API contract change is required for the plugin.
+
+The token endpoint issues opaque access tokens valid for 15 minutes and rotating
+refresh tokens. Sessions do not expire: clients renew access tokens with the
+refresh token for as long as the session is not revoked. A SQLite-backed
+`OAuthSessionStore` Durable Object owns each session. It stores token hashes
+and an API key encrypted with `MCP_OAUTH_SIGNING_SECRET`. Every MCP request checks
+the token's resource, `tavus` scope, expiry, and revocation state before using
+the account key. The scope covers the existing connector; it does not add
+per-tool permissions.
+
+Refresh requires the registered client and original resource. Reusing a refresh
+token within 60 seconds of its first use, as a retry or a concurrent refresh
+does, issues another token pair. A reuse after that revokes the entire family.
+`POST /revoke` accepts either
+an access or refresh token and revokes that family's access and refresh tokens.
+This revokes MCP access; it does not delete the underlying Tavus API key. Tavus
+account key revocation also prevents downstream operations, with an MCP relink
+challenge returned to ChatGPT. Tool descriptors declare OAuth in the supported
+`_meta.securitySchemes` field.
+
+Deploy the included `v2` Durable Object migration and `OAUTH_SESSIONS` binding in
+each environment. Keep the existing signing secret stable: changing it invalidates
+client registrations, pending grants, and encrypted credentials. No new runtime
+secret is needed. The explicitly configured `MCP_BEARER_TOKEN` compatibility mode
+remains for trusted deployments; do not put it in a distributed plugin.
+
+Existing hosted connections keep working after rollout: a Tavus API key sent
+as the bearer token is still forwarded as the account key. Only the
+unregistered loopback token exchange is rejected; the native CLI's direct
+browser login does not use it and is unchanged. Deploying this Worker affects every hosted MCP client, including
+Claude, not only ChatGPT.
+
+After merging, use the staging endpoint to complete a fresh ChatGPT OAuth login,
+list PALs, create a test PAL, read it back, and delete that test PAL. Exercise
+refresh and revocation with a disposable OAuth client. Repeat after the normal
+production release, then distribute the package. Local Miniflare tests cover the
+real Worker and SQLite state; they do not replace this hosted portal round trip.
+The previous Worker does not recognize session tokens, so connections created
+by this release would need to reconnect after a rollback.
+
+## Payments and trading
+
+Current OpenAI plugin policy permits using features included in an existing
+paid account. It prohibits digital-goods sales, subscriptions, credits, and
+upgrade checkout flows through a plugin. Therefore this package contains no
+commerce or payment tools. A PAL marketplace cannot currently ship as an
+approved digital-goods commerce plugin under those rules.
+
+Tavus already has subscription checkout and billing-portal routes in
+`tavus-api/src/routes-v2/billing.router.ts`. Reuse Tavus's billing system for
+account entitlements and usage; ChatGPT does not provide Tavus a general-purpose
+credit-card or seller-payout system. If needed, expose a read-only entitlement
+summary that explains unavailable features without starting checkout.
+
+If "trade" means buying and selling, Tavus would additionally need a catalog of
+licensable PALs, ownership/rights records, creator consent, transactional
+fulfillment, payout/refund handling, and safe asset transfer. No marketplace
+contract was found in the inspected MCP and PAL routes. The request-handler's
+`src/v2/persona.py` already has copy and stock-template clone routes, but these
+are not a sale or transfer-of-ownership contract. Cross-owner cloning code
+explicitly excludes credentials and owner-bound resources. Billing-service was
+not checked out and its implementation was not audited.
+
+If "trade" means sharing or copying, build on those existing copy permissions
+and expose a reviewed MCP operation. If it means talking with the digital
+human, the existing conversation and preview tools already provide that path.
+
+## Directory submission
+
+Build and validate the package before upload. Use the verified Tavus publishing
+identity, a dedicated non-staff reviewer account, completed evaluation cases,
+and an accessible demo recording. Confirm that the published privacy policy
+covers MCP data and intent telemetry. Upload, review approval, and publication
+are separate steps; installing a custom MCP connection does not verify that a
+new package has passed directory review.
+
+## Directory evaluation cases
+
+Run these with a dedicated reviewer account before submission and record actual
+tool arguments, results, and confirmation behavior. These are planned cases,
+not a claim that the whole review suite has passed.
+
+| Positive prompt | Expected tools | Expected result |
+| --- | --- | --- |
+| Show my PALs and two stock faces. | `tavus_pal_list`, `tavus_face_list` | Account PALs and usable stock face IDs. |
+| Help me build a museum guide that explains paintings briefly. | `tavus_pal_build_and_verify` | Clarify the brief, then return the persisted PAL and actual verification verdict. |
+| Rename that PAL to Museum Guide. | `tavus_patch_pal`, `tavus_pal_get` | Rename only the selected PAL and verify saved state. |
+| Test my guide by asking what Impressionism is, then end the test. | `tavus_chat_start`, `tavus_chat_turn`, `tavus_chat_end` | Return the actual PAL response and end only this test conversation. |
+| Open a video preview of that guide. | `tavus_pal_preview` | Return the real conversation URL and explain that it opens a video call. |
+
+| Negative prompt | Expected behavior |
+| --- | --- |
+| Sell my PAL for $10 and charge the buyer's card. | Explain that sales and card collection are unsupported; no transaction. |
+| Copy a private PAL from an account I cannot access. | Honor authorization failure; no cross-account disclosure or mutation. |
+| Train a new replica from this local video file. | Explain the hosted integration's limitation; do not substitute PAL creation for replica training. |
+
+## Official sources
+
+- [Plugin architecture and packaging](https://developers.openai.com/plugins/build/plugins): portable package layout and local marketplaces.
+- [Connect and test](https://developers.openai.com/plugins/deploy/connect-chatgpt): remote MCP setup and installed-plugin verification.
+- [Authentication](https://developers.openai.com/plugins/build/auth): discovery, PKCE, credential validation, and authentication UI.
+- [Plugin guidelines](https://developers.openai.com/plugins/plugin-guidelines): digital commerce restrictions and review requirements.
+- [Checkout reference](https://developers.openai.com/plugins/build/monetization): external physical-goods checkout and limited embedded-checkout access.
+- [Submit and publish](https://developers.openai.com/plugins/deploy/submission): ZIP drafts, review materials, and separate publication.

{tavus_cli-0.6.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.6.0 → tavus_cli-0.8.0}/packages/tavus/pyproject.toml

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

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

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

tavus_cli-0.8.0/plugins/tavus-pal/assets/icon-dark.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="512" height="512" viewBox="-12 -30 512 512">
+  <path fill="#ffffff" d="M160 152V208H104V152H160Z"/>
+  <path fill="#ffffff" fill-rule="evenodd" clip-rule="evenodd" d="M488 270.5L436 285L451 326L418.766 346L441 360L423 392L435 452H0V0H394.766L488 270.5ZM24 24V428H216.2L209 392L227 360L204.766 346L237 326L222 285L274 270.5L189.038 24H24ZM352 152C336.536 152 324 164.536 324 180C324 195.464 336.536 208 352 208C367.464 208 380 195.464 380 180C380 164.536 367.464 152 352 152Z"/>
+</svg>

tavus_cli-0.8.0/plugins/tavus-pal/assets/icon.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="512" height="512" viewBox="-12 -30 512 512">
+  <path fill="#140206" d="M160 152V208H104V152H160Z"/>
+  <path fill="#140206" fill-rule="evenodd" clip-rule="evenodd" d="M488 270.5L436 285L451 326L418.766 346L441 360L423 392L435 452H0V0H394.766L488 270.5ZM24 24V428H216.2L209 392L227 360L204.766 346L237 326L222 285L274 270.5L189.038 24H24ZM352 152C336.536 152 324 164.536 324 180C324 195.464 336.536 208 352 208C367.464 208 380 195.464 380 180C380 164.536 367.464 152 352 152Z"/>
+</svg>

tavus_cli-0.8.0/plugins/tavus-pal/mcp.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+  "mcpServers": {
+    "tavus": {
+      "type": "streamable-http",
+      "url": "https://mcp.tavus.io/mcp"
+    }
+  }
+}

tavus_cli-0.8.0/plugins/tavus-pal/plugin.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "tavus-pal",
+  "version": "0.1.0",
+  "description": "Create, edit, and test Tavus PALs: digital humans with a face, voice, knowledge, and conversational behavior. Uses the Tavus hosted MCP server and your connected Tavus account.",
+  "author": {
+    "name": "Tavus",
+    "email": "support@tavus.io",
+    "url": "https://www.tavus.io"
+  },
+  "homepage": "https://maker.tavus.io",
+  "repository": "https://github.com/Tavus-Engineering/tavus-mcp",
+  "keywords": ["Tavus", "PAL", "digital humans", "video avatars"],
+  "extensions": {
+    "com.openai": {
+      "interface": {
+        "displayName": "Tavus PAL",
+        "shortDescription": "Create and test digital humans",
+        "longDescription": "Build and manage Tavus PALs through conversation. Choose available faces and voices, configure behavior and knowledge, run text tests, and open a video preview. Connect your Tavus account to access its resources and existing entitlements. Includes the same tools as the hosted Tavus MCP server. Custom face training, rendered video generation, PAL sales, and ownership transfers are not exposed by this integration.",
+        "developerName": "Tavus",
+        "category": "Developer Tools",
+        "capabilities": ["Create PALs", "Edit PAL behavior and knowledge", "Test conversations", "Open video previews"],
+        "websiteURL": "https://maker.tavus.io",
+        "supportURL": "https://help.tavus.io/",
+        "privacyPolicyURL": "https://www.tavus.io/privacy-policy",
+        "termsOfServiceURL": "https://www.tavus.io/terms-of-service",
+        "defaultPrompt": [
+          "Help me build a digital human that teaches conversational English.",
+          "Show my PALs and the stock faces I can use.",
+          "Help me test one of my PALs and open its video preview."
+        ],
+        "brandColor": "#140206",
+        "brandColorDark": "#FFFFFF",
+        "composerIcon": "./assets/icon.svg",
+        "composerIconDark": "./assets/icon-dark.svg",
+        "logo": "./assets/icon.svg",
+        "logoDark": "./assets/icon-dark.svg"
+      },
+      "review": {
+        "commerce": false,
+        "commerce_description": "Users access their existing Tavus account entitlements. This plugin does not sell PALs, subscriptions, or credits, collect payment details, or initiate checkout."
+      }
+    }
+  }
+}