pipecatcloud 0.2.8__tar.gz → 0.2.10__tar.gz

{pipecatcloud-0.2.8 → pipecatcloud-0.2.10}/CHANGELOG.md

@@ -5,6 +5,25 @@ 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.10] - 2025-10-25
+
+### Removed
+
+- The `init` command was removed. Use the `pipecat-ai-cli`'s `init` command to
+  scaffold your project.
+
+## [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

{pipecatcloud-0.2.8/src/pipecatcloud.egg-info → pipecatcloud-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipecatcloud
-Version: 0.2.8
+Version: 0.2.10
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.daily.co/
@@ -13,7 +13,7 @@ Requires-Dist: fastapi<0.117.0,>=0.115.6
 Requires-Dist: loguru~=0.7.3
 Requires-Dist: python-dotenv<2.0.0,>=1.0.1
 Requires-Dist: uvicorn<1.0.0,>=0.32.0
-Requires-Dist: typer<0.17.0,>=0.15.3
+Requires-Dist: typer<1,>=0.20.0
 Requires-Dist: synchronicity~=0.7.6
 Requires-Dist: toml~=0.10.2
 Requires-Dist: questionary~=2.1.0

{pipecatcloud-0.2.8 → pipecatcloud-0.2.10}/pyproject.toml

@@ -16,7 +16,7 @@ dependencies = [
     "loguru~=0.7.3",
     "python-dotenv>=1.0.1,<2.0.0",
     "uvicorn>=0.32.0,<1.0.0",
-    "typer>=0.15.3,<0.17.0",
+    "typer>=0.20.0,<1",
     "synchronicity~=0.7.6",
     "toml~=0.10.2",
     "questionary~=2.1.0"

{pipecatcloud-0.2.8 → pipecatcloud-0.2.10}/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.8 → pipecatcloud-0.2.10}/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.8 → pipecatcloud-0.2.10}/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.8 → pipecatcloud-0.2.10}/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.8 → pipecatcloud-0.2.10}/src/pipecatcloud/cli/entry_point.py

@@ -14,7 +14,6 @@ from pipecatcloud.cli.commands.agent import agent_cli
 from pipecatcloud.cli.commands.auth import auth_cli
 from pipecatcloud.cli.commands.deploy import create_deploy_command
 from pipecatcloud.cli.commands.docker import create_docker_command
-from pipecatcloud.cli.commands.init import create_init_command
 from pipecatcloud.cli.commands.organizations import organization_cli
 from pipecatcloud.cli.commands.run import create_run_command
 from pipecatcloud.cli.commands.secrets import secrets_cli
@@ -62,10 +61,8 @@ entrypoint_cli_typer = typer.Typer(
     no_args_is_help=True,
     add_completion=False,
     rich_markup_mode="markdown",
-    help="""
-    ᓚᘏᗢ Pipecat Cloud CLI
-    See website at https://pipecat.daily.co
-    """,
+    short_help="Deploy and manage bots on Pipecat Cloud",
+    help="ᓚᘏᗢ Pipecat Cloud CLI. See website at https://pipecat.daily.co",
 )
 
 
@@ -79,7 +76,6 @@ def cli(
 
 
 create_run_command(entrypoint_cli_typer)
-create_init_command(entrypoint_cli_typer)
 create_deploy_command(entrypoint_cli_typer)
 create_docker_command(entrypoint_cli_typer)
 entrypoint_cli_typer.add_typer(auth_cli, rich_help_panel="Commands")

pipecatcloud-0.2.10/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.8 → pipecatcloud-0.2.10/src/pipecatcloud.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipecatcloud
-Version: 0.2.8
+Version: 0.2.10
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.daily.co/
@@ -13,7 +13,7 @@ Requires-Dist: fastapi<0.117.0,>=0.115.6
 Requires-Dist: loguru~=0.7.3
 Requires-Dist: python-dotenv<2.0.0,>=1.0.1
 Requires-Dist: uvicorn<1.0.0,>=0.32.0
-Requires-Dist: typer<0.17.0,>=0.15.3
+Requires-Dist: typer<1,>=0.20.0
 Requires-Dist: synchronicity~=0.7.6
 Requires-Dist: toml~=0.10.2
 Requires-Dist: questionary~=2.1.0

{pipecatcloud-0.2.8 → pipecatcloud-0.2.10}/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
@@ -38,7 +39,6 @@ src/pipecatcloud/cli/commands/agent.py
 src/pipecatcloud/cli/commands/auth.py
 src/pipecatcloud/cli/commands/deploy.py
 src/pipecatcloud/cli/commands/docker.py
-src/pipecatcloud/cli/commands/init.py
 src/pipecatcloud/cli/commands/organizations.py
 src/pipecatcloud/cli/commands/run.py
 src/pipecatcloud/cli/commands/secrets.py
@@ -47,4 +47,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.8 → pipecatcloud-0.2.10}/src/pipecatcloud.egg-info/requires.txt

@@ -3,7 +3,7 @@ fastapi<0.117.0,>=0.115.6
 loguru~=0.7.3
 python-dotenv<2.0.0,>=1.0.1
 uvicorn<1.0.0,>=0.32.0
-typer<0.17.0,>=0.15.3
+typer<1,>=0.20.0
 synchronicity~=0.7.6
 toml~=0.10.2
 questionary~=2.1.0

pipecatcloud-0.2.10/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

pipecatcloud-0.2.8/src/pipecatcloud/cli/commands/init.py

@@ -1,142 +0,0 @@
-#
-# Copyright (c) 2025, Daily
-#
-# SPDX-License-Identifier: BSD 2-Clause License
-#
-
-import os
-import warnings
-import zipfile
-from typing import Set
-
-import aiohttp
-import questionary
-import typer
-
-from pipecatcloud._utils.async_utils import synchronizer
-from pipecatcloud._utils.console_utils import console
-from pipecatcloud.config import config
-
-# ----- Init
-
-FILES_TO_EXTRACT = {
-    "pipecat-quickstart-main/bot.py",
-    "pipecat-quickstart-main/Dockerfile",
-    "pipecat-quickstart-main/pcc-deploy.toml",
-    "pipecat-quickstart-main/README.md",
-    "pipecat-quickstart-main/.gitignore",
-    "pipecat-quickstart-main/env.example",
-    "pipecat-quickstart-main/pyproject.toml",
-    "pipecat-quickstart-main/uv.lock",
-}
-
-
-def check_existing_files() -> Set[str]:
-    """Check which target files already exist in the current directory."""
-    return {
-        os.path.basename(file)
-        for file in FILES_TO_EXTRACT
-        if os.path.exists(os.path.basename(file))
-    }
-
-
-def create_init_command(app: typer.Typer):
-    @app.command(
-        name="init",
-        help="[DEPRECATED] Initialize project directory with template files",
-        deprecated=True,
-    )
-    @synchronizer.create_blocking
-    async def init():
-        warnings.warn(
-            "The 'pcc init' command is deprecated and will be removed in a future version. "
-            "Please use the Pipecat CLI instead: https://github.com/pipecat-ai/pipecat-cli",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        console.print(
-            "[yellow]Warning:[/yellow] The 'pcc init' command is deprecated and will be removed in a future version.\n"
-            "Please use the Pipecat CLI instead: "
-            "[link=https://github.com/pipecat-ai/pipecat-cli]https://github.com/pipecat-ai/pipecat-cli[/link]"
-        )
-
-        if not await questionary.confirm(
-            "This will download the latest starter project to the current directory. Continue?"
-        ).ask_async():
-            console.print("[bold]Aborting init request[/bold]")
-            return typer.Exit(1)
-
-        # Check existing files more efficiently
-        existing_files = check_existing_files()
-        if existing_files:
-            files_list = "\n".join(f"- {f}" for f in existing_files)
-            if not await questionary.confirm(
-                f"The following files already exist and will be overwritten:\n{files_list}\nDo you want to continue?"
-            ).ask_async():
-                console.print("[bold]Aborting init request[/bold]")
-                return typer.Exit(1)
-
-        zip_path = "init.zip"
-        try:
-            with console.status("[dim]Downloading starter project...[/dim]", spinner="dots"):
-                zip_url = config.get("init_zip_url")
-                if not zip_url:
-                    raise ValueError("No starter project URL found in configuration")
-
-                async with aiohttp.ClientSession() as session:
-                    async with session.get(zip_url) as response:
-                        if response.status != 200:
-                            raise aiohttp.ClientResponseError(
-                                response.request_info,
-                                response.history,
-                                status=response.status,
-                                message=f"Failed to download starter project: {response.reason}",
-                            )
-
-                        # Stream the download to a file
-                        with open(zip_path, "wb") as f:
-                            async for chunk in response.content.iter_chunked(8192):
-                                f.write(chunk)
-
-                # Extract files
-                with zipfile.ZipFile(zip_path, "r") as zip_ref:
-                    for file in FILES_TO_EXTRACT:
-                        try:
-                            source = zip_ref.read(file)
-                            target = os.path.basename(file)
-                            with open(target, "wb") as f:
-                                f.write(source)
-                        except KeyError:
-                            console.print(
-                                f"[yellow]Warning:[/yellow] File {file} not found in starter project"
-                            )
-                        except Exception as e:
-                            raise Exception(f"Failed to extract {file}: {str(e)}")
-
-            console.success(
-                "You can now start building your agent in [bold]bot.py[/bold]"
-                "\n\n"
-                "Follow the steps in the [bold]README.md[/bold] file to get started.",
-                title="Project files downloaded successfully",
-            )
-
-        except aiohttp.ClientError as e:
-            console.error(f"Network error while downloading starter project: {str(e)}")
-            return typer.Exit(1)
-        except zipfile.BadZipFile:
-            console.error("Downloaded file is not a valid zip archive")
-            return typer.Exit(1)
-        except Exception as e:
-            console.error(f"Error during initialization: {str(e)}")
-            return typer.Exit(1)
-        finally:
-            # Cleanup the temporary zip file
-            if os.path.exists(zip_path):
-                try:
-                    os.remove(zip_path)
-                except Exception as e:
-                    console.print(
-                        f"[yellow]Warning:[/yellow] Failed to cleanup temporary file {zip_path}: {str(e)}"
-                    )
-
-    return init