pipecatcloud 0.2.7__tar.gz → 0.2.9__tar.gz

{pipecatcloud-0.2.7 → pipecatcloud-0.2.9}/CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to **Pipecat Cloud** will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.9] - 2025-10-24
+
+### Added
+
+- Added Krisp VIVA audio filtering support with the `--krisp-viva-audio-filter`
+  option to the `deploy` command. Supports `tel` (telephone) and `pro` (professional)
+  audio filter models. Can also be configured via `pcc-deploy.toml` by adding a
+  `[krisp_viva]` section with `audio_filter = "tel"` or `audio_filter = "pro"`.
+
+- `agent status` now displays the Krisp VIVA configuration state, showing whether
+  it's enabled and which audio filter model is active.
+
+## [0.2.8] - 2025-10-24
+
+### Added
+
+- Register pipecat cloud commands as `pipecat-cli` extensions.
+
 ## [0.2.7] - 2025-10-21
 
 ### Added

{pipecatcloud-0.2.7/src/pipecatcloud.egg-info → pipecatcloud-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipecatcloud
-Version: 0.2.7
+Version: 0.2.9
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.daily.co/

{pipecatcloud-0.2.7 → pipecatcloud-0.2.9}/pyproject.toml

@@ -42,6 +42,9 @@ dev = [
 pcc = "pipecatcloud.__main__:main"
 pipecatcloud = "pipecatcloud.__main__:main"
 
+[project.entry-points."pipecat_cli.extensions"]
+cloud = "pipecatcloud.cli.entry_point:entrypoint_cli_typer"
+
 [tool.setuptools]
 package-dir = {"" = "src"}
 

{pipecatcloud-0.2.7 → pipecatcloud-0.2.9}/src/pipecatcloud/_utils/deploy_utils.py

@@ -12,6 +12,7 @@ import toml
 from attr import dataclass, field
 from loguru import logger
 
+from pipecatcloud.constants import KRISP_VIVA_MODELS, KrispVivaAudioFilter
 from pipecatcloud.exception import ConfigFileError
 
 DEPLOY_STATUS_MAP = {
@@ -56,6 +57,23 @@ class ScalingParams:
         return {"min_agents": self.min_agents, "max_agents": self.max_agents}
 
 
+@dataclass
+class KrispVivaConfig:
+    audio_filter: Optional[KrispVivaAudioFilter] = None
+
+    def __attrs_post_init__(self):
+        # Validation against known models
+        # IMPORTANT: KRISP_VIVA_MODELS must be kept in sync with API configuration
+        if self.audio_filter is not None:
+            if self.audio_filter not in KRISP_VIVA_MODELS:
+                raise ValueError(
+                    f"audio_filter must be one of {KRISP_VIVA_MODELS}, got '{self.audio_filter}'"
+                )
+
+    def to_dict(self):
+        return {"audio_filter": self.audio_filter}
+
+
 @dataclass
 class DeployConfigParams:
     agent_name: Optional[str] = None
@@ -67,6 +85,7 @@ class DeployConfigParams:
     enable_managed_keys: bool = False
     docker_config: dict = field(factory=dict)
     agent_profile: Optional[str] = None
+    krisp_viva: KrispVivaConfig = field(factory=KrispVivaConfig)
 
     def __attrs_post_init__(self):
         if self.image is not None and ":" not in self.image:
@@ -83,6 +102,7 @@ class DeployConfigParams:
             "enable_managed_keys": self.enable_managed_keys,
             "docker_config": self.docker_config,
             "agent_profile": self.agent_profile,
+            "krisp_viva": self.krisp_viva.to_dict() if self.krisp_viva else None,
         }
 
 
@@ -106,11 +126,16 @@ def load_deploy_config_file() -> Optional[DeployConfigParams]:
         # Extract docker configuration if present
         docker_data = config_data.pop("docker", {})
 
+        # Extract krisp_viva configuration if present
+        krisp_viva_data = config_data.pop("krisp_viva", {})
+        krisp_viva_config = KrispVivaConfig(**krisp_viva_data)
+
         # Create DeployConfigParams with validated data
         validated_config = DeployConfigParams(
             **config_data,
             scaling=scaling_params,
             docker_config=docker_data,
+            krisp_viva=krisp_viva_config,
         )
 
         # Check for unexpected keys
@@ -124,6 +149,7 @@ def load_deploy_config_file() -> Optional[DeployConfigParams]:
             "enable_managed_keys",
             "docker",
             "agent_profile",
+            "krisp_viva",
         }
         unexpected_keys = set(config_data.keys()) - expected_keys
         if unexpected_keys:

{pipecatcloud-0.2.7 → pipecatcloud-0.2.9}/src/pipecatcloud/api.py

@@ -323,6 +323,9 @@ class _API:
             "enableKrisp": deploy_config.enable_krisp,
             "enableIntegratedKeysProxy": deploy_config.enable_managed_keys,  # API expects this field name
             "agentProfile": deploy_config.agent_profile,
+            "krispViva": {
+                "audioFilter": deploy_config.krisp_viva.audio_filter,
+            },
         }
 
         # Remove None values recursively

{pipecatcloud-0.2.7 → pipecatcloud-0.2.9}/src/pipecatcloud/cli/commands/agent.py

@@ -165,6 +165,20 @@ async def status(
             "[green]Enabled[/green]" if integrated_keys_enabled else "[dim]Disabled[/dim]",
         )
 
+        # Check for Krisp VIVA status (reverse-mapped by API)
+        krisp_viva = data.get("krispViva")
+        krisp_viva_status = "[dim]Disabled[/dim]"
+
+        if krisp_viva and isinstance(krisp_viva, dict):
+            audio_filter = krisp_viva.get("audioFilter")
+            if audio_filter:
+                krisp_viva_status = f"[green]Enabled ({audio_filter})[/green]"
+
+        deployment_table.add_row(
+            "[bold]Krisp VIVA:[/bold]",
+            krisp_viva_status,
+        )
+
         # Autoscaling info
         autoscaling_data = data.get("autoScaling", None)
         if autoscaling_data:

{pipecatcloud-0.2.7 → pipecatcloud-0.2.9}/src/pipecatcloud/cli/commands/deploy.py

@@ -19,9 +19,11 @@ from pipecatcloud._utils.auth_utils import requires_login
 from pipecatcloud._utils.console_utils import console
 from pipecatcloud._utils.deploy_utils import (
     DeployConfigParams,
+    KrispVivaConfig,
     ScalingParams,
     with_deploy_config,
 )
+from pipecatcloud.constants import KRISP_VIVA_MODELS
 from pipecatcloud.cli import PIPECAT_CLI_NAME
 from pipecatcloud.cli.api import API
 from pipecatcloud.cli.config import config
@@ -276,7 +278,7 @@ def create_deploy_command(app: typer.Typer):
             False,
             "--enable-krisp",
             "-krisp",
-            help="Enable Krisp integration for this deployment",
+            help="[DEPRECATED] Enable Krisp integration for this deployment. Use --krisp-viva-audio-filter instead",
             rich_help_panel="Deployment Configuration",
         ),
         managed_keys: bool = typer.Option(
@@ -285,6 +287,12 @@ def create_deploy_command(app: typer.Typer):
             help="Enable Managed Keys for this deployment",
             rich_help_panel="Deployment Configuration",
         ),
+        krisp_viva_audio_filter: str = typer.Option(
+            None,
+            "--krisp-viva-audio-filter",
+            help=f"Enable Krisp VIVA with audio filter model ({' or '.join(KRISP_VIVA_MODELS)})",
+            rich_help_panel="Deployment Configuration",
+        ),
         profile: str = typer.Option(
             None,
             "--profile",
@@ -334,6 +342,9 @@ def create_deploy_command(app: typer.Typer):
             logger.warning("max_instances is deprecated, use max_agents instead")
             max_agents = max_instances
 
+        if krisp:
+            logger.warning("--enable-krisp is deprecated, use --krisp-viva-audio-filter instead for the latest Krisp VIVA models.")
+
         org = organization or config.get("org")
 
         # Compose deployment config from CLI options and config file (if provided)
@@ -361,6 +372,10 @@ def create_deploy_command(app: typer.Typer):
         partial_config.enable_managed_keys = managed_keys or partial_config.enable_managed_keys
         partial_config.agent_profile = profile or partial_config.agent_profile
 
+        # Handle Krisp VIVA configuration
+        if krisp_viva_audio_filter is not None:
+            partial_config.krisp_viva = KrispVivaConfig(audio_filter=krisp_viva_audio_filter)
+
         # Assert agent name and image are provided
         if not partial_config.agent_name:
             console.error("Agent name is required")
@@ -397,7 +412,8 @@ def create_deploy_command(app: typer.Typer):
             (f"[bold white]Secret set:[/bold white] {'[dim]None[/dim]' if not partial_config.secret_set else '[green] '+ partial_config.secret_set + '[/green]'}"),
             (f"[bold white]Image pull secret:[/bold white] {'[dim]None[/dim]' if not partial_config.image_credentials else '[green]' + partial_config.image_credentials + '[/green]'}"),
             (f"[bold white]Agent profile:[/bold white] {'[dim]None[/dim]' if not partial_config.agent_profile else '[green]' + partial_config.agent_profile + '[/green]'}"),
-            (f"[bold white]Krisp:[/bold white] {'[dim]Disabled[/dim]' if not partial_config.enable_krisp else '[green]Enabled[/green]'}"),
+            (f"[bold white]Krisp (deprecated):[/bold white] {'[dim]Disabled[/dim]' if not partial_config.enable_krisp else '[green]Enabled[/green]'}"),
+            (f"[bold white]Krisp VIVA:[/bold white] {'[dim]Disabled[/dim]' if not partial_config.krisp_viva.audio_filter else '[green]Enabled (' + partial_config.krisp_viva.audio_filter + ')[/green]'}"),
             (f"[bold white]Managed Keys:[/bold white] {'[dim]Disabled[/dim]' if not partial_config.enable_managed_keys else '[green]Enabled[/green]'}"),
             "\n[dim]Scaling configuration:[/dim]",
             table,

{pipecatcloud-0.2.7 → pipecatcloud-0.2.9}/src/pipecatcloud/cli/commands/docker.py

@@ -336,7 +336,7 @@ async def build_push(
         console.print("\n[dim]To deploy this image, update your pcc-deploy.toml:[/dim]")
         console.print(f'  [bold]image = "{version_tag}"[/bold]')
         console.print("\n[dim]Then run:[/dim]")
-        console.print("  [bold]pipecatcloud deploy[/bold]")
+        console.print("  [bold]pipecat cloud deploy[/bold]")
 
 
 def create_docker_command(app: typer.Typer):

pipecatcloud-0.2.9/src/pipecatcloud/constants.py

@@ -0,0 +1,22 @@
+#
+# Copyright (c) 2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""
+Constants for Pipecat Cloud CLI.
+
+IMPORTANT: These values must be kept in sync with API configuration.
+When adding new models or options, update both the API ConfigMap and these constants.
+"""
+
+from typing import Literal, get_args
+
+# Krisp VIVA audio filter models
+# These must match the keys in the API's KRISP_AUDIO_FILTER_MODELS ConfigMap
+# Location: pipecat-cloud-sandbox/api/helm/chart/values.yaml -> krispConfig.audioFilterModels
+KrispVivaAudioFilter = Literal["tel", "pro"]
+
+# Derive runtime list from the Literal type for validation
+KRISP_VIVA_MODELS = list(get_args(KrispVivaAudioFilter))

{pipecatcloud-0.2.7 → pipecatcloud-0.2.9/src/pipecatcloud.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipecatcloud
-Version: 0.2.7
+Version: 0.2.9
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.daily.co/

{pipecatcloud-0.2.7 → pipecatcloud-0.2.9}/src/pipecatcloud.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ src/pipecatcloud/__version__.py
 src/pipecatcloud/agent.py
 src/pipecatcloud/api.py
 src/pipecatcloud/config.py
+src/pipecatcloud/constants.py
 src/pipecatcloud/exception.py
 src/pipecatcloud/py.typed
 src/pipecatcloud/session.py
@@ -47,4 +48,5 @@ tests/__init__.py
 tests/test_agent_sessions.py
 tests/test_agent_stop.py
 tests/test_docker_commands.py
+tests/test_krisp_viva.py
 tests/test_managed_keys.py

{pipecatcloud-0.2.7 → pipecatcloud-0.2.9}/src/pipecatcloud.egg-info/entry_points.txt

@@ -1,3 +1,6 @@
 [console_scripts]
 pcc = pipecatcloud.__main__:main
 pipecatcloud = pipecatcloud.__main__:main
+
+[pipecat_cli.extensions]
+cloud = pipecatcloud.cli.entry_point:entrypoint_cli_typer

pipecatcloud-0.2.9/tests/test_krisp_viva.py

@@ -0,0 +1,647 @@
+"""
+Unit tests for Krisp VIVA feature.
+
+Tests follow AAA pattern and focus on behaviors/outcomes rather than implementation details.
+Covers data model, TOML parsing, CLI commands, API integration, and validation.
+"""
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from src.pipecatcloud._utils.deploy_utils import (
+    DeployConfigParams,
+    KrispVivaConfig,
+    load_deploy_config_file,
+)
+from src.pipecatcloud.api import _API
+from src.pipecatcloud.constants import KRISP_VIVA_MODELS
+
+
+class TestKrispVivaDataModel:
+    """Test the KrispVivaConfig data model."""
+
+    def test_default_is_disabled(self):
+        """When not specified, Krisp VIVA should default to disabled."""
+        # Arrange & Act
+        config = KrispVivaConfig()
+
+        # Assert
+        assert config.audio_filter is None
+
+    def test_can_set_tel_model(self):
+        """Tel audio filter model can be explicitly set."""
+        # Arrange & Act
+        config = KrispVivaConfig(audio_filter="tel")
+
+        # Assert
+        assert config.audio_filter == "tel"
+
+    def test_can_set_pro_model(self):
+        """Pro audio filter model can be explicitly set."""
+        # Arrange & Act
+        config = KrispVivaConfig(audio_filter="pro")
+
+        # Assert
+        assert config.audio_filter == "pro"
+
+    def test_rejects_invalid_model(self):
+        """Invalid audio filter models should be rejected."""
+        # Arrange & Act & Assert
+        with pytest.raises(ValueError, match="audio_filter must be one of"):
+            KrispVivaConfig(audio_filter="invalid-model")
+
+    def test_validation_uses_constants(self):
+        """Validation should use KRISP_VIVA_MODELS constant."""
+        # Arrange & Act & Assert
+        with pytest.raises(ValueError) as exc_info:
+            KrispVivaConfig(audio_filter="bad-model")
+
+        # Assert error message includes the models from constants
+        error_message = str(exc_info.value)
+        for model in KRISP_VIVA_MODELS:
+            assert model in error_message
+
+    def test_to_dict_when_disabled(self):
+        """Dictionary representation when disabled should have null audio_filter."""
+        # Arrange
+        config = KrispVivaConfig()
+
+        # Act
+        result = config.to_dict()
+
+        # Assert
+        assert result == {"audio_filter": None}
+
+    def test_to_dict_when_enabled(self):
+        """Dictionary representation when enabled should include the model."""
+        # Arrange
+        config = KrispVivaConfig(audio_filter="tel")
+
+        # Act
+        result = config.to_dict()
+
+        # Assert
+        assert result == {"audio_filter": "tel"}
+
+
+class TestDeployConfigIntegration:
+    """Test DeployConfigParams integration with Krisp VIVA."""
+
+    def test_default_krisp_viva_is_disabled(self):
+        """When not specified, Krisp VIVA should default to disabled."""
+        # Arrange & Act
+        config = DeployConfigParams()
+
+        # Assert
+        assert config.krisp_viva is not None
+        assert config.krisp_viva.audio_filter is None
+
+    def test_can_enable_krisp_viva(self):
+        """Krisp VIVA can be explicitly enabled with a model."""
+        # Arrange & Act
+        config = DeployConfigParams(krisp_viva=KrispVivaConfig(audio_filter="tel"))
+
+        # Assert
+        assert config.krisp_viva.audio_filter == "tel"
+
+    def test_krisp_viva_included_in_dict_representation(self):
+        """Dictionary representation should include Krisp VIVA configuration."""
+        # Arrange
+        config = DeployConfigParams(
+            agent_name="test-agent", krisp_viva=KrispVivaConfig(audio_filter="pro")
+        )
+
+        # Act
+        result = config.to_dict()
+
+        # Assert
+        assert "krisp_viva" in result
+        assert result["krisp_viva"]["audio_filter"] == "pro"
+
+    def test_krisp_viva_preserves_other_settings(self):
+        """Adding Krisp VIVA should not affect other configuration settings."""
+        # Arrange
+        config = DeployConfigParams(
+            agent_name="test-agent",
+            image="test:latest",
+            enable_krisp=True,
+            enable_managed_keys=True,
+            krisp_viva=KrispVivaConfig(audio_filter="tel"),
+        )
+
+        # Act
+        result = config.to_dict()
+
+        # Assert
+        assert result["agent_name"] == "test-agent"
+        assert result["image"] == "test:latest"
+        assert result["enable_krisp"] is True
+        assert result["enable_managed_keys"] is True
+        assert result["krisp_viva"]["audio_filter"] == "tel"
+
+
+class TestTOMLConfiguration:
+    """Test TOML configuration file parsing with Krisp VIVA."""
+
+    @pytest.fixture
+    def temp_config_file(self, tmp_path):
+        """Create a temporary TOML config file."""
+        config_path = tmp_path / "pcc-deploy.toml"
+        return config_path
+
+    def test_loads_krisp_viva_tel_from_toml(self, temp_config_file):
+        """TOML file with Krisp VIVA tel model should be parsed correctly."""
+        # Arrange
+        config_content = """
+        agent_name = "test-agent"
+        image = "test:latest"
+
+        [krisp_viva]
+        audio_filter = "tel"
+        """
+        temp_config_file.write_text(config_content)
+
+        # Act
+        with patch("pipecatcloud.cli.config.deploy_config_path", str(temp_config_file)):
+            config = load_deploy_config_file()
+
+        # Assert
+        assert config is not None
+        assert config.krisp_viva.audio_filter == "tel"
+
+    def test_loads_krisp_viva_pro_from_toml(self, temp_config_file):
+        """TOML file with Krisp VIVA pro model should be parsed correctly."""
+        # Arrange
+        config_content = """
+        agent_name = "test-agent"
+        image = "test:latest"
+
+        [krisp_viva]
+        audio_filter = "pro"
+        """
+        temp_config_file.write_text(config_content)
+
+        # Act
+        with patch("pipecatcloud.cli.config.deploy_config_path", str(temp_config_file)):
+            config = load_deploy_config_file()
+
+        # Assert
+        assert config is not None
+        assert config.krisp_viva.audio_filter == "pro"
+
+    def test_rejects_invalid_model_from_toml(self, temp_config_file):
+        """TOML file with invalid Krisp VIVA model should raise error."""
+        # Arrange
+        config_content = """
+        agent_name = "test-agent"
+        image = "test:latest"
+
+        [krisp_viva]
+        audio_filter = "invalid-model"
+        """
+        temp_config_file.write_text(config_content)
+
+        # Act & Assert
+        with patch("pipecatcloud.cli.config.deploy_config_path", str(temp_config_file)):
+            with pytest.raises(Exception):  # ConfigFileError wraps ValueError
+                load_deploy_config_file()
+
+    def test_defaults_when_not_in_toml(self, temp_config_file):
+        """TOML file without Krisp VIVA should default to disabled."""
+        # Arrange
+        config_content = """
+        agent_name = "test-agent"
+        image = "test:latest"
+        """
+        temp_config_file.write_text(config_content)
+
+        # Act
+        with patch("pipecatcloud.cli.config.deploy_config_path", str(temp_config_file)):
+            config = load_deploy_config_file()
+
+        # Assert
+        assert config is not None
+        assert config.krisp_viva.audio_filter is None
+
+    def test_preserves_other_settings_with_krisp_viva(self, temp_config_file):
+        """Krisp VIVA setting should not interfere with other TOML settings."""
+        # Arrange
+        config_content = """
+        agent_name = "test-agent"
+        image = "test:latest"
+        enable_krisp = true
+        enable_managed_keys = true
+        secret_set = "my-secrets"
+
+        [scaling]
+        min_agents = 2
+        max_agents = 10
+
+        [krisp_viva]
+        audio_filter = "pro"
+        """
+        temp_config_file.write_text(config_content)
+
+        # Act
+        with patch("pipecatcloud.cli.config.deploy_config_path", str(temp_config_file)):
+            config = load_deploy_config_file()
+
+        # Assert
+        assert config.agent_name == "test-agent"
+        assert config.image == "test:latest"
+        assert config.enable_krisp is True
+        assert config.enable_managed_keys is True
+        assert config.secret_set == "my-secrets"
+        assert config.scaling.min_agents == 2
+        assert config.scaling.max_agents == 10
+        assert config.krisp_viva.audio_filter == "pro"
+
+
+class TestAPIIntegration:
+    """Test API client integration with Krisp VIVA."""
+
+    @pytest.fixture
+    def api_client(self):
+        """Create an API client instance."""
+        return _API(token="test-token", is_cli=True)
+
+    @pytest.mark.asyncio
+    async def test_deploy_payload_includes_krisp_viva_tel(self, api_client):
+        """Deploy payload should include krispViva with tel model."""
+        # Arrange
+        config = DeployConfigParams(
+            agent_name="test-agent",
+            image="test:latest",
+            krisp_viva=KrispVivaConfig(audio_filter="tel"),
+        )
+
+        with patch.object(api_client, "_base_request", new_callable=AsyncMock) as mock_request:
+            mock_request.return_value = {"success": True}
+
+            # Act
+            await api_client._deploy(config, "test-org", update=False)
+
+            # Assert
+            mock_request.assert_called_once()
+            payload = mock_request.call_args[1]["json"]
+            assert "krispViva" in payload
+            assert payload["krispViva"]["audioFilter"] == "tel"
+
+    @pytest.mark.asyncio
+    async def test_deploy_payload_includes_krisp_viva_pro(self, api_client):
+        """Deploy payload should include krispViva with pro model."""
+        # Arrange
+        config = DeployConfigParams(
+            agent_name="test-agent",
+            image="test:latest",
+            krisp_viva=KrispVivaConfig(audio_filter="pro"),
+        )
+
+        with patch.object(api_client, "_base_request", new_callable=AsyncMock) as mock_request:
+            mock_request.return_value = {"success": True}
+
+            # Act
+            await api_client._deploy(config, "test-org", update=False)
+
+            # Assert
+            mock_request.assert_called_once()
+            payload = mock_request.call_args[1]["json"]
+            assert "krispViva" in payload
+            assert payload["krispViva"]["audioFilter"] == "pro"
+
+    @pytest.mark.asyncio
+    async def test_update_payload_includes_krisp_viva(self, api_client):
+        """Update payload should include krispViva field."""
+        # Arrange
+        config = DeployConfigParams(
+            agent_name="test-agent",
+            image="test:latest",
+            krisp_viva=KrispVivaConfig(audio_filter="tel"),
+        )
+
+        with patch.object(api_client, "_base_request", new_callable=AsyncMock) as mock_request:
+            mock_request.return_value = {"success": True}
+
+            # Act
+            await api_client._deploy(config, "test-org", update=True)
+
+            # Assert
+            mock_request.assert_called_once()
+            payload = mock_request.call_args[1]["json"]
+            assert "krispViva" in payload
+            assert payload["krispViva"]["audioFilter"] == "tel"
+
+    @pytest.mark.asyncio
+    async def test_disabled_krisp_viva_sends_empty_object(self, api_client):
+        """When Krisp VIVA is disabled, API should send empty krispViva object."""
+        # Arrange
+        config = DeployConfigParams(
+            agent_name="test-agent", image="test:latest", krisp_viva=KrispVivaConfig()
+        )
+
+        with patch.object(api_client, "_base_request", new_callable=AsyncMock) as mock_request:
+            mock_request.return_value = {"success": True}
+
+            # Act
+            await api_client._deploy(config, "test-org", update=False)
+
+            # Assert
+            mock_request.assert_called_once()
+            payload = mock_request.call_args[1]["json"]
+            assert "krispViva" in payload
+            # None values are filtered out by remove_none_values, leaving empty dict
+            assert payload["krispViva"] == {}
+
+
+class TestAgentStatusDisplay:
+    """Test agent status command displays Krisp VIVA status."""
+
+    @pytest.fixture
+    def mock_api(self):
+        """Mock the API agent method."""
+        with patch("src.pipecatcloud.cli.commands.agent.API") as mock_api:
+            yield mock_api
+
+    def test_displays_enabled_krisp_viva_tel(self, mock_api, capsys):
+        """Agent status should display when Krisp VIVA is enabled with tel model."""
+        # Arrange
+        from src.pipecatcloud.cli.commands.agent import status
+
+        mock_api.agent = AsyncMock(
+            return_value=(
+                {
+                    "ready": True,
+                    "deployment": {"manifest": {"spec": {}}},
+                    "krispViva": {"audioFilter": "tel"},
+                    "autoScaling": {
+                        "minReplicas": 0,
+                        "maxReplicas": 1,
+                    },
+                },
+                None,
+            )
+        )
+
+        # Act
+        status(agent_name="test-agent", organization="test-org")
+
+        # Assert
+        captured = capsys.readouterr()
+        assert "Krisp VIVA" in captured.out
+        assert "Enabled" in captured.out
+        assert "tel" in captured.out
+
+    def test_displays_enabled_krisp_viva_pro(self, mock_api, capsys):
+        """Agent status should display when Krisp VIVA is enabled with pro model."""
+        # Arrange
+        from src.pipecatcloud.cli.commands.agent import status
+
+        mock_api.agent = AsyncMock(
+            return_value=(
+                {
+                    "ready": True,
+                    "deployment": {"manifest": {"spec": {}}},
+                    "krispViva": {"audioFilter": "pro"},
+                    "autoScaling": {
+                        "minReplicas": 0,
+                        "maxReplicas": 1,
+                    },
+                },
+                None,
+            )
+        )
+
+        # Act
+        status(agent_name="test-agent", organization="test-org")
+
+        # Assert
+        captured = capsys.readouterr()
+        assert "Krisp VIVA" in captured.out
+        assert "Enabled" in captured.out
+        assert "pro" in captured.out
+
+    def test_displays_disabled_krisp_viva(self, mock_api, capsys):
+        """Agent status should display when Krisp VIVA is disabled."""
+        # Arrange
+        from src.pipecatcloud.cli.commands.agent import status
+
+        mock_api.agent = AsyncMock(
+            return_value=(
+                {
+                    "ready": True,
+                    "deployment": {"manifest": {"spec": {}}},
+                    "autoScaling": {
+                        "minReplicas": 0,
+                        "maxReplicas": 1,
+                    },
+                },
+                None,
+            )
+        )
+
+        # Act
+        status(agent_name="test-agent", organization="test-org")
+
+        # Assert
+        captured = capsys.readouterr()
+        assert "Krisp VIVA" in captured.out
+        assert "Disabled" in captured.out
+
+    def test_handles_null_audio_filter(self, mock_api, capsys):
+        """Agent status should handle krispViva with null audioFilter."""
+        # Arrange
+        from src.pipecatcloud.cli.commands.agent import status
+
+        mock_api.agent = AsyncMock(
+            return_value=(
+                {
+                    "ready": True,
+                    "deployment": {"manifest": {"spec": {}}},
+                    "krispViva": {"audioFilter": None},
+                    "autoScaling": {
+                        "minReplicas": 0,
+                        "maxReplicas": 1,
+                    },
+                },
+                None,
+            )
+        )
+
+        # Act
+        status(agent_name="test-agent", organization="test-org")
+
+        # Assert
+        captured = capsys.readouterr()
+        assert "Krisp VIVA" in captured.out
+        assert "Disabled" in captured.out
+
+    def test_handles_missing_krisp_viva_field(self, mock_api, capsys):
+        """Agent status should handle responses without krispViva field."""
+        # Arrange
+        from src.pipecatcloud.cli.commands.agent import status
+
+        mock_api.agent = AsyncMock(
+            return_value=(
+                {
+                    "ready": True,
+                    "deployment": {"manifest": {"spec": {}}},
+                    "autoScaling": {
+                        "minReplicas": 0,
+                        "maxReplicas": 1,
+                    },
+                },
+                None,
+            )
+        )
+
+        # Act
+        status(agent_name="test-agent", organization="test-org")
+
+        # Assert
+        captured = capsys.readouterr()
+        assert "Krisp VIVA" in captured.out
+        assert "Disabled" in captured.out
+
+
+class TestBackwardCompatibility:
+    """Test backward compatibility with existing deployments."""
+
+    def test_existing_config_without_krisp_viva_works(self):
+        """Existing configs without Krisp VIVA field should work unchanged."""
+        # Arrange
+        config = DeployConfigParams(agent_name="test-agent", image="test:latest", enable_krisp=True)
+
+        # Act
+        result = config.to_dict()
+
+        # Assert
+        assert result["enable_krisp"] is True
+        assert result["krisp_viva"]["audio_filter"] is None
+
+    def test_api_response_without_krisp_viva_doesnt_crash(self):
+        """Agent status should handle API responses without Krisp VIVA field."""
+        # Arrange
+        data = {"ready": True, "deployment": {"manifest": {"spec": {"image": "test:latest"}}}}
+
+        # Act - simulate the logic from agent.py
+        krisp_viva = data.get("krispViva")
+        krisp_viva_status = "[dim]Disabled[/dim]"
+
+        if krisp_viva and isinstance(krisp_viva, dict):
+            audio_filter = krisp_viva.get("audioFilter")
+            if audio_filter:
+                krisp_viva_status = f"[green]Enabled ({audio_filter})[/green]"
+
+        # Assert
+        assert krisp_viva_status == "[dim]Disabled[/dim]"
+
+    @pytest.fixture
+    def temp_legacy_config(self, tmp_path):
+        """Create a legacy TOML config without Krisp VIVA."""
+        config_path = tmp_path / "pcc-deploy.toml"
+        config_content = """
+        agent_name = "legacy-agent"
+        image = "legacy:latest"
+        enable_krisp = true
+        enable_managed_keys = true
+
+        [scaling]
+        min_agents = 1
+        max_agents = 5
+        """
+        config_path.write_text(config_content)
+        return config_path
+
+    def test_legacy_toml_loads_with_defaults(self, temp_legacy_config):
+        """Legacy TOML files should load with Krisp VIVA defaulting to disabled."""
+        # Arrange & Act
+        with patch("pipecatcloud.cli.config.deploy_config_path", str(temp_legacy_config)):
+            config = load_deploy_config_file()
+
+        # Assert
+        assert config is not None
+        assert config.agent_name == "legacy-agent"
+        assert config.enable_krisp is True
+        assert config.enable_managed_keys is True
+        assert config.krisp_viva.audio_filter is None
+
+
+class TestErrorHandling:
+    """Test error handling and edge cases."""
+
+    @pytest.mark.asyncio
+    async def test_api_error_during_deploy_with_krisp_viva(self):
+        """API errors during deployment with Krisp VIVA should be handled properly."""
+        # Arrange
+        api = _API(token="test-token", is_cli=True)
+        config = DeployConfigParams(
+            agent_name="test-agent",
+            image="test:latest",
+            krisp_viva=KrispVivaConfig(audio_filter="tel"),
+        )
+
+        with patch.object(api, "_base_request", new_callable=AsyncMock) as mock_request:
+            mock_request.side_effect = Exception("Network error")
+
+            # Act & Assert
+            with pytest.raises(Exception, match="Network error"):
+                await api._deploy(config, "test-org", update=False)
+
+    def test_simultaneous_krisp_and_krisp_viva(self):
+        """Both Krisp and Krisp VIVA can be enabled simultaneously."""
+        # Arrange
+        config = DeployConfigParams(
+            agent_name="test-agent",
+            image="test:latest",
+            enable_krisp=True,
+            krisp_viva=KrispVivaConfig(audio_filter="tel"),
+        )
+
+        # Act
+        result = config.to_dict()
+
+        # Assert
+        assert result["enable_krisp"] is True
+        assert result["krisp_viva"]["audio_filter"] == "tel"
+
+    def test_all_features_enabled_together(self):
+        """Krisp, Managed Keys, and Krisp VIVA can all be enabled together."""
+        # Arrange
+        config = DeployConfigParams(
+            agent_name="test-agent",
+            image="test:latest",
+            enable_krisp=True,
+            enable_managed_keys=True,
+            krisp_viva=KrispVivaConfig(audio_filter="pro"),
+        )
+
+        # Act
+        result = config.to_dict()
+
+        # Assert
+        assert result["enable_krisp"] is True
+        assert result["enable_managed_keys"] is True
+        assert result["krisp_viva"]["audio_filter"] == "pro"
+
+
+class TestConstantsSynchronization:
+    """Test that constants are properly synchronized and used."""
+
+    def test_all_models_in_constants_are_valid(self):
+        """All models in KRISP_VIVA_MODELS should be accepted."""
+        # Arrange & Act & Assert
+        for model in KRISP_VIVA_MODELS:
+            config = KrispVivaConfig(audio_filter=model)
+            assert config.audio_filter == model
+
+    def test_constants_not_empty(self):
+        """KRISP_VIVA_MODELS should not be empty."""
+        # Arrange & Act & Assert
+        assert len(KRISP_VIVA_MODELS) > 0
+
+    def test_constants_contain_expected_models(self):
+        """KRISP_VIVA_MODELS should contain expected default models."""
+        # Arrange & Act & Assert
+        assert "tel" in KRISP_VIVA_MODELS
+        assert "pro" in KRISP_VIVA_MODELS