tavus-cli 0.4.4__tar.gz → 0.5.0__tar.gz

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

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

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.5.0](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.4.5...v0.5.0) (2026-09-30)
+
+
+### Features
+
+* record why agents call each MCP tool ([#51](https://github.com/Tavus-Engineering/tavus-mcp/issues/51)) ([1059388](https://github.com/Tavus-Engineering/tavus-mcp/commit/10593882a1f08a87a29e14f24bfdc7a3f53f0797))
+
+## [0.4.5](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.4.4...v0.4.5) (2026-09-29)
+
+
+### Bug Fixes
+
+* accept Cursor and IPv6 loopback DCR callbacks ([#49](https://github.com/Tavus-Engineering/tavus-mcp/issues/49)) ([8c9d9f3](https://github.com/Tavus-Engineering/tavus-mcp/commit/8c9d9f3a0cd42bb51080a84b0982a9c4ad64f175))
+
 ## [0.4.4](https://github.com/Tavus-Engineering/tavus-mcp/compare/v0.4.3...v0.4.4) (2026-09-10)
 
 

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/PKG-INFO

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

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/docs/usage-observability.md

@@ -9,9 +9,27 @@ Tavus API requests with a source-specific user agent:
 | Local MCP server | `tavus-mcp/<version>` |
 | Hosted MCP Worker | `tavus-mcp-worker/<version>` |
 
-They also send the matching low-cardinality `X-Tavus-Client-Source` header. The
-header is available for future structured attribution; the user agent works with
-request-handler's current access logging today.
+They also send the matching low-cardinality `X-Tavus-Client-Source` header.
+
+## Tool intent
+
+Every MCP tool on both servers accepts an optional `intent` argument. The
+calling agent uses it to say, in one sentence, why it called the tool and what
+the user is trying to get done. Agents may leave it out, and a call never fails
+because of it.
+
+Each Tavus API request made during a tool call carries two more headers:
+
+| Header | Value |
+| --- | --- |
+| `X-Tavus-Client-Tool` | The MCP tool name, such as `tavus_pal_get` |
+| `X-Tavus-Client-Intent` | The intent, when given: whitespace collapsed, cut to 500 characters, and percent-encoded outside printable ASCII (`%` becomes `%25`) |
+
+Request-handler logs all three `X-Tavus-Client-*` headers in the `headers` field
+of `log_request_data`, so intent sits next to the URL and joins to `user_id` on
+`trace_id` like the rest of this data. Decode the intent with any URL decoder,
+such as Python's `urllib.parse.unquote`. One tool call can make several API
+requests, and each one carries the same tool name and intent.
 
 ## SigNoz data path
 
@@ -59,7 +77,11 @@ historical rows until this source tagging is released.
 - Counts are downstream Tavus API requests, not top-level MCP tool calls or CLI
   invocations. Local-only operations such as help, auth status, path listing, and
   embed scaffolding do not generate an API request and are not counted.
-- No API key, prompt, or request body is added to telemetry by this change. The
-  source tags contain only the product surface and package version. Request-handler
-  continues applying its existing API-key truncation and 64 KiB body-redaction
-  policy.
+- The source tags contain only the product surface and package version.
+  Request-handler continues applying its existing API-key truncation and 64 KiB
+  body-redaction policy.
+- Intent is free text written by the calling agent. The argument description
+  asks agents to leave out secrets and personal details, but nothing enforces
+  that, so treat logged intent with the same care as logged request bodies.
+- Tool calls that make no Tavus API request, such as `tavus_scaffold_embed`, do
+  not record their intent.

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/packages/tavus/pyproject.toml

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

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/packages/tavus-mcp/pyproject.toml

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

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/pyproject.toml

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

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/src/tavus_mcp/__init__.py

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

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/src/tavus_mcp/sdk/client/http.py

@@ -2,9 +2,13 @@ from __future__ import annotations
 
 import json as _json
 import mimetypes
+from collections.abc import Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar
 from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
-from typing import Any, Self
+from typing import Any, NamedTuple, Self
+from urllib.parse import quote
 
 import httpx
 
@@ -25,6 +29,33 @@ from tavus_mcp.sdk.schemas.tool import AttachToolsBody, ToolCreate, ToolUpdate
 
 BUILDER_LLM_TIMEOUT_S = 120.0
 CLIENT_SOURCE_HEADER = "X-Tavus-Client-Source"
+CLIENT_TOOL_HEADER = "X-Tavus-Client-Tool"
+CLIENT_INTENT_HEADER = "X-Tavus-Client-Intent"
+MAX_INTENT_LENGTH = 500
+# Header values must be printable ASCII. Everything else, and "%" itself, is
+# percent-encoded so request-handler logs stay readable and decodable.
+_INTENT_HEADER_SAFE = "".join(chr(code) for code in range(0x20, 0x7F) if chr(code) != "%")
+
+
+class _ToolCall(NamedTuple):
+    tool: str
+    intent: str | None
+
+
+_current_tool_call: ContextVar[_ToolCall | None] = ContextVar(
+    "tavus_current_tool_call", default=None
+)
+
+
+@contextmanager
+def tool_call_context(tool: str, intent: str | None) -> Iterator[None]:
+    """Tag Tavus API requests made inside an MCP tool call with its name and intent."""
+    normalized = " ".join((intent or "").split())[:MAX_INTENT_LENGTH] or None
+    token = _current_tool_call.set(_ToolCall(tool, normalized))
+    try:
+        yield
+    finally:
+        _current_tool_call.reset(token)
 
 
 def _public_pal_error_body(value: Any) -> Any:
@@ -59,11 +90,19 @@ def _client_headers(api_key: str, surface: str) -> dict[str, str]:
         raise ValueError(
             "surface must contain only lowercase letters, numbers, '.', '_', or '-'"
         )
-    return {
+    headers = {
         "x-api-key": api_key,
         "User-Agent": f"tavus-{normalized_surface}/{_package_version()}",
         CLIENT_SOURCE_HEADER: normalized_surface,
     }
+    tool_call = _current_tool_call.get()
+    if tool_call is not None:
+        headers[CLIENT_TOOL_HEADER] = tool_call.tool
+        if tool_call.intent:
+            headers[CLIENT_INTENT_HEADER] = quote(
+                tool_call.intent, safe=_INTENT_HEADER_SAFE, errors="replace"
+            )
+    return headers
 
 
 class TavusClient:

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/src/tavus_mcp/server.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
 
+import functools
+import inspect
 import time
-from typing import Any, Literal
+from typing import Annotated, Any, Literal
 
 from fastmcp import FastMCP
+from pydantic import Field
 
 from tavus_mcp.sdk import daily_transport
 from tavus_mcp.sdk.auth.session import get_session
-from tavus_mcp.sdk.client.http import TavusClient
+from tavus_mcp.sdk.client.http import TavusClient, tool_call_context
 from tavus_mcp.sdk.env import load_config
 from tavus_mcp.sdk.recipes.build_and_verify import build_and_verify
 from tavus_mcp.sdk.recipes.capabilities import (
@@ -106,27 +109,52 @@ def _annotations_for_tool(name: str) -> dict[str, bool]:
     }
 
 
+INTENT_DESCRIPTION = (
+    "Optional. One sentence on why you are calling this tool: what the user is "
+    "trying to get done. Tavus stores it to improve these tools. Leave out "
+    "secrets and personal details."
+)
+
+_INTENT_PARAMETER = inspect.Parameter(
+    "intent",
+    inspect.Parameter.KEYWORD_ONLY,
+    default=None,
+    annotation=Annotated[str | None, Field(description=INTENT_DESCRIPTION)],
+)
+
+
+def _with_intent(fn: Any, tool_name: str) -> Any:
+    """Add the optional ``intent`` argument and tag the call's API requests with it."""
+
+    @functools.wraps(fn)
+    async def call_with_intent(*args: Any, intent: str | None = None, **kwargs: Any) -> Any:
+        with tool_call_context(tool_name, intent):
+            return await fn(*args, **kwargs)
+
+    signature = inspect.signature(fn)
+    call_with_intent.__signature__ = signature.replace(  # type: ignore[attr-defined]
+        parameters=[*signature.parameters.values(), _INTENT_PARAMETER]
+    )
+    call_with_intent.__annotations__ = {
+        **fn.__annotations__,
+        "intent": _INTENT_PARAMETER.annotation,
+    }
+    return call_with_intent
+
+
 class AnnotatedFastMCP(FastMCP):
-    """Apply a conservative annotation policy to every registered Tavus tool."""
+    """Apply the Tavus annotation and intent policy to every registered 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)
+        if isinstance(name_or_fn, str):
+            kwargs["name"] = name_or_fn
+            name_or_fn = None
+        if name_or_fn is None:
+            return lambda fn: self.tool(fn, **kwargs)
+        name = kwargs.get("name") or name_or_fn.__name__
+        if kwargs.get("annotations") is None:
+            kwargs["annotations"] = _annotations_for_tool(name)
+        return super().tool(_with_intent(name_or_fn, name), **kwargs)
 
 
 mcp = AnnotatedFastMCP(

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/tests/integration/test_mcp_server.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 from pathlib import Path
+from urllib.parse import unquote
 
 import pytest
 import respx
+from fastmcp import Client
 from httpx import Response
 
 from tavus_mcp.sdk.errors import TavusApiError
@@ -102,6 +104,39 @@ async def test_mcp_requests_identify_the_mcp_surface(clean_env: Path) -> None:
     request = route.calls.last.request
     assert request.headers["user-agent"].startswith("tavus-mcp/")
     assert request.headers["x-tavus-client-source"] == "mcp"
+    assert request.headers["x-tavus-client-tool"] == "tavus_pal_list"
+    assert "x-tavus-client-intent" not in request.headers
+
+
+@pytest.mark.asyncio
+async def test_every_tool_offers_an_optional_intent() -> None:
+    for tool in await mcp.list_tools():
+        assert "intent" in tool.parameters["properties"], tool.name
+        assert "intent" not in tool.parameters.get("required", []), tool.name
+
+
+@pytest.mark.asyncio
+@respx.mock
+async def test_mcp_requests_carry_the_encoded_intent(clean_env: Path) -> None:
+    (clean_env / ".env").write_text(
+        "TAVUS_ENV=TEST\n"
+        "TAVUS_API_KEY=test-key\n"
+        "TAVUS_PUBLIC_API_BASE_URL=https://api.example.test/v2\n"
+    )
+    route = respx.get("https://api.example.test/v2/pals/p1").mock(
+        return_value=Response(200, json={"pal_id": "p1"})
+    )
+
+    async with Client(mcp) as client:
+        await client.call_tool(
+            "tavus_pal_get",
+            {"pal_id": "p1", "intent": "  Check the café PAL\nbefore 100% launch  "},
+        )
+
+    headers = route.calls.last.request.headers
+    assert headers["x-tavus-client-tool"] == "tavus_pal_get"
+    assert headers["x-tavus-client-intent"] == "Check the caf%C3%A9 PAL before 100%25 launch"
+    assert unquote(headers["x-tavus-client-intent"]) == "Check the café PAL before 100% launch"
 
 
 @pytest.mark.asyncio

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/uv.lock

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

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/workers/tavus-mcp/package-lock.json

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

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/workers/tavus-mcp/package.json

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

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/workers/tavus-mcp/src/oauth.ts

@@ -712,7 +712,10 @@ function isAllowedResource(rawResource: string, expectedResource: string): boole
 function isLoopbackUrl(raw: string): boolean {
   try {
     const url = new URL(raw);
-    return url.protocol === "http:" && (url.hostname === "127.0.0.1" || url.hostname === "localhost");
+    return (
+      url.protocol === "http:" &&
+      (url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "[::1]")
+    );
   } catch {
     return false;
   }
@@ -764,6 +767,16 @@ function trustedRemoteClientName(raw: string): string | undefined {
   ) {
     return "ChatGPT";
   }
+  // Cursor registers its hosted callback rather than a loopback listener when
+  // its loopback-redirect flag is off, so DCR fails without this entry.
+  if (
+    url.protocol === "https:" &&
+    (url.hostname === "cursor.com" || url.hostname === "www.cursor.com") &&
+    url.pathname === "/agents/mcp/oauth/callback" &&
+    !url.search
+  ) {
+    return "Cursor";
+  }
   return undefined;
 }
 

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/workers/tavus-mcp/src/tavus.ts

@@ -1,4 +1,8 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RegisteredTool } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 
 import type { OAuthGrantKind } from "./oauth-grant";
@@ -83,6 +87,66 @@ export const DEFAULT_PAL_LLM_MODEL = "tavus-gemma-4";
 const CLIENT_SOURCE = "mcp-worker";
 const CLIENT_VERSION = VERSION;
 
+export const INTENT_DESCRIPTION =
+  "Optional. One sentence on why you are calling this tool: what the user is " +
+  "trying to get done. Tavus stores it to improve these tools. Leave out " +
+  "secrets and personal details.";
+const MAX_INTENT_LENGTH = 500;
+
+interface ToolCall {
+  tool: string;
+  intent?: string;
+}
+
+type ToolHandler = (args: Record<string, unknown>, extra: unknown) => unknown;
+
+const currentToolCall = new AsyncLocalStorage<ToolCall>();
+
+function normalizeIntent(intent: unknown): string | undefined {
+  if (typeof intent !== "string") return undefined;
+  const collapsed = intent.trim().split(/\s+/).join(" ");
+  // Truncate by code point so an emoji is never split into a lone surrogate.
+  return Array.from(collapsed).slice(0, MAX_INTENT_LENGTH).join("") || undefined;
+}
+
+// Header values must be printable ASCII. Everything else, and "%" itself, is
+// percent-encoded so request-handler logs stay readable and decodable.
+function intentHeaderValue(intent: string): string {
+  return intent.replace(/[^\x20-\x24\x26-\x7e]/gu, (char) =>
+    /\p{Cs}/u.test(char) ? "?" : encodeURIComponent(char),
+  );
+}
+
+// Adds the optional intent argument to every tool and tags the Tavus API
+// requests a call makes with the tool name and intent.
+function addToolIntent(server: McpServer): void {
+  const register = server.tool.bind(server) as (...args: unknown[]) => RegisteredTool;
+  server.tool = ((...args: unknown[]) => {
+    if (args.length !== 5) {
+      throw new Error(
+        `Register ${String(args[0])} with server.tool(name, description, schema, annotations, handler).`,
+      );
+    }
+    const [name, description, schema, annotations, handler] = args as [
+      string,
+      string,
+      z.ZodRawShape,
+      ToolAnnotations,
+      ToolHandler,
+    ];
+    return register(
+      name,
+      description,
+      { ...schema, intent: z.string().optional().describe(INTENT_DESCRIPTION) },
+      annotations,
+      ({ intent, ...toolArgs }: Record<string, unknown>, extra: unknown) =>
+        currentToolCall.run({ tool: name, intent: normalizeIntent(intent) }, () =>
+          handler(toolArgs, extra),
+        ),
+    );
+  }) as McpServer["tool"];
+}
+
 const DEFAULT_PUBLIC_API_BASE_URLS: Record<TavusEnvironment, string> = {
   TEST: "https://test.rqh.tavusapi.com/v2",
   STG: "https://stg.rqh.tavusapi.com/v2",
@@ -449,6 +513,7 @@ export function createTavusMcpServer(env: Env, apiKey?: string): McpServer {
     name: "tavus",
     version: VERSION,
   });
+  addToolIntent(server);
 
   server.tool(
     "tavus_mcp_health_check",
@@ -2520,12 +2585,20 @@ class TavusApiClient {
 }
 
 export function tavusApiRequestHeaders(apiKey: string): Record<string, string> {
-  return {
+  const headers: Record<string, string> = {
     "Content-Type": "application/json",
     "User-Agent": `tavus-${CLIENT_SOURCE}/${CLIENT_VERSION}`,
     "X-Tavus-Client-Source": CLIENT_SOURCE,
     "x-api-key": apiKey,
   };
+  const toolCall = currentToolCall.getStore();
+  if (toolCall) {
+    headers["X-Tavus-Client-Tool"] = toolCall.tool;
+    if (toolCall.intent) {
+      headers["X-Tavus-Client-Intent"] = intentHeaderValue(toolCall.intent);
+    }
+  }
+  return headers;
 }
 
 async function firstStockFaceId(client: TavusApiClient): Promise<string> {

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

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

{tavus_cli-0.4.4 → tavus_cli-0.5.0}/workers/tavus-mcp/test/tavus.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
+import type { z } from "zod";
 
 import {
   handleOAuthRequest,
@@ -322,6 +323,51 @@ describe("Cloudflare Tavus MCP helpers", () => {
     });
   });
 
+  it("offers an optional intent argument on every hosted tool", () => {
+    const tools = registeredTools(createTavusMcpServer({ TAVUS_API_KEY: "secret" }));
+    for (const [name, tool] of Object.entries(tools)) {
+      const shape = (tool as unknown as { inputSchema: { shape: Record<string, z.ZodType> } })
+        .inputSchema.shape;
+      expect(shape.intent, `${name} intent`).toBeDefined();
+      expect(shape.intent.safeParse(undefined).success, `${name} intent optional`).toBe(true);
+    }
+  });
+
+  it("tags API requests with the tool name and encoded intent", async () => {
+    const fetchMock = vi.fn(async () =>
+      new Response(JSON.stringify({ pal_id: "p1" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    try {
+      const tool = registeredTools(createTavusMcpServer({ TAVUS_API_KEY: "secret" }))
+        .tavus_pal_get;
+      await tool.handler({
+        pal_id: "p1",
+        include_settings: false,
+        intent: "  Check the café PAL\nbefore 100% launch  ",
+      });
+      await tool.handler({ pal_id: "p1", include_settings: false });
+
+      const [withIntent, withoutIntent] = fetchMock.mock.calls.map(
+        (call) => (call as unknown as [string, RequestInit])[1].headers as Record<string, string>,
+      );
+      expect(withIntent).toMatchObject({
+        "X-Tavus-Client-Tool": "tavus_pal_get",
+        "X-Tavus-Client-Intent": "Check the caf%C3%A9 PAL before 100%25 launch",
+      });
+      expect(decodeURIComponent(withIntent["X-Tavus-Client-Intent"])).toBe(
+        "Check the café PAL before 100% launch",
+      );
+      expect(withoutIntent["X-Tavus-Client-Tool"]).toBe("tavus_pal_get");
+      expect(withoutIntent).not.toHaveProperty("X-Tavus-Client-Intent");
+    } finally {
+      vi.unstubAllGlobals();
+    }
+  });
+
   it("identifies hosted MCP requests without exposing the API key in the user agent", () => {
     expect(tavusApiRequestHeaders("secret")).toMatchObject({
       "User-Agent": `tavus-mcp-worker/${VERSION}`,
@@ -718,6 +764,47 @@ describe("Cloudflare Tavus MCP helpers", () => {
     });
   });
 
+  it("allows Cursor DCR callbacks and canonicalizes the client name", async () => {
+    const response = await handleOAuthRequest(
+      new Request("https://mcp.tavus-preview.io/register", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          redirect_uris: ["https://www.cursor.com/agents/mcp/oauth/callback"],
+          client_name: "Attacker-controlled label",
+        }),
+      }),
+      { MCP_OAUTH_SIGNING_SECRET: "s".repeat(32) },
+      "/mcp",
+    );
+
+    expect(response?.status).toBe(201);
+    await expect(response?.json()).resolves.toMatchObject({
+      client_name: "Cursor",
+      redirect_uris: ["https://www.cursor.com/agents/mcp/oauth/callback"],
+    });
+  });
+
+  it("allows IPv6 loopback DCR callbacks", async () => {
+    const response = await handleOAuthRequest(
+      new Request("https://mcp.tavus-preview.io/register", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          redirect_uris: ["http://[::1]:53117/oauth/callback"],
+          client_name: "MCP Client",
+        }),
+      }),
+      { MCP_OAUTH_SIGNING_SECRET: "s".repeat(32) },
+      "/mcp",
+    );
+
+    expect(response?.status).toBe(201);
+    await expect(response?.json()).resolves.toMatchObject({
+      redirect_uris: ["http://[::1]:53117/oauth/callback"],
+    });
+  });
+
   it("rejects arbitrary HTTPS dynamic client callbacks", async () => {
     const response = await handleOAuthRequest(
       new Request("https://mcp.tavus-preview.io/register", {

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

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

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

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