pipecatcloud 0.3.1__tar.gz → 0.4.0__tar.gz

{pipecatcloud-0.3.1 → pipecatcloud-0.4.0}/CHANGELOG.md

@@ -5,6 +5,33 @@ 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.4.0] - 2026-03-29
+
+### Added
+
+- **`--config-file` flag**: Specify an alternate deploy config file on any
+  command that uses a config file (`deploy`, `agent sessions`, `agent start`,
+  `agent stop`, `docker build-push`). Enables multi-environment workflows
+  without renaming files or setting environment variables.
+
+### Changed
+
+- Renamed `--config` to `--show-cli-config` for clarity — it displays internal
+  CLI state (credentials, active org), not deploy configuration.
+
+### Removed
+
+- Removed `--enable-managed-keys` CLI option from `deploy` command.
+
+- Removed `enable_managed_keys` from `pcc-deploy.toml` configuration.
+
+- Removed "Managed Keys" status display from `agent status` output.
+
+### Fixed
+
+- CLI no longer crashes on a malformed credentials file. It warns and allows
+  `auth login` to run so the user can fix it.
+
 ## [0.3.1] - 2026-03-13
 
 ### Added

{pipecatcloud-0.3.1 → pipecatcloud-0.4.0}/PKG-INFO

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

{pipecatcloud-0.3.1 → pipecatcloud-0.4.0}/src/pipecatcloud/_utils/deploy_utils.py

@@ -10,10 +10,13 @@ from datetime import datetime, timezone
 from enum import Enum
 from typing import Callable, List, Optional
 
+
 import toml
+import typer
 from attr import dataclass, field
 from loguru import logger
 
+from pipecatcloud.cli import PIPECAT_DEPLOY_CONFIG_PATH
 from pipecatcloud.constants import KRISP_VIVA_MODELS, KrispVivaAudioFilter
 from pipecatcloud.exception import ConfigFileError
 
@@ -280,7 +283,6 @@ class DeployConfigParams:
     region: Optional[str] = None
     scaling: ScalingParams = ScalingParams()
     enable_krisp: bool = False
-    enable_managed_keys: bool = False
     docker_config: dict = field(factory=dict)
     build_config: BuildConfig = field(factory=BuildConfig)  # Cloud build configuration
     agent_profile: Optional[str] = None
@@ -303,7 +305,6 @@ class DeployConfigParams:
             "region": self.region,
             "scaling": self.scaling.to_dict() if self.scaling else None,
             "enable_krisp": self.enable_krisp,
-            "enable_managed_keys": self.enable_managed_keys,
             "docker_config": self.docker_config,
             "build_config": self.build_config.to_dict() if self.build_config else None,
             "agent_profile": self.agent_profile,
@@ -363,7 +364,6 @@ def load_deploy_config_file() -> Optional[DeployConfigParams]:
             "region",
             "scaling",
             "enable_krisp",
-            "enable_managed_keys",
             "docker",
             "build",
             "agent_profile",
@@ -380,14 +380,34 @@ def load_deploy_config_file() -> Optional[DeployConfigParams]:
         raise ConfigFileError(str(e))
 
 
+CONFIG_FILE_OPTION: Optional[str] = typer.Option(
+    None,
+    "--config-file",
+    help=f"Path to deploy config file (default: {PIPECAT_DEPLOY_CONFIG_PATH})",
+)
+
+
 def with_deploy_config(func: Callable) -> Callable:
     """
     Decorator that loads the deploy config file and injects it into the function.
     If the config file exists, it will be loaded and passed to the function as `deploy_config`.
+
+    If the wrapped function receives a `config_file` kwarg (from a --config-file typer option),
+    it will override the default deploy config path before loading.
     """
 
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
+        config_file = kwargs.pop("config_file", None)
+        if config_file:
+            import pipecatcloud.cli.config as config_module
+
+            if not os.path.exists(config_file):
+                from pipecatcloud._utils.console_utils import console
+
+                console.error(f"Deploy config file not found: {config_file}")
+                raise typer.Exit(1)
+            config_module.deploy_config_path = config_file
         try:
             deploy_config = load_deploy_config_file()
             kwargs["deploy_config"] = deploy_config

{pipecatcloud-0.3.1 → pipecatcloud-0.4.0}/src/pipecatcloud/api.py

@@ -336,7 +336,6 @@ class _API:
                 "maxAgents": deploy_config.scaling.max_agents,
             },
             "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,

{pipecatcloud-0.3.1 → pipecatcloud-0.4.0}/src/pipecatcloud/cli/commands/agent.py

@@ -28,7 +28,11 @@ from pipecatcloud._utils.console_utils import (
     format_duration,
     format_timestamp,
 )
-from pipecatcloud._utils.deploy_utils import DeployConfigParams, with_deploy_config
+from pipecatcloud._utils.deploy_utils import (
+    CONFIG_FILE_OPTION,
+    DeployConfigParams,
+    with_deploy_config,
+)
 from pipecatcloud._utils.regions import get_region_codes, validate_region
 from pipecatcloud.cli import PIPECAT_CLI_NAME
 from pipecatcloud.cli.api import API
@@ -206,24 +210,6 @@ async def status(
             str(data.get("updatedAt", "N/A")),
         )
 
-        # Check for Managed Keys status
-        # API returns integratedKeysProxy but we display as "Managed Keys"
-        integrated_keys = (
-            data.get("deployment", {})
-            .get("manifest", {})
-            .get("spec", {})
-            .get("integratedKeysProxy", {})
-        )
-        if isinstance(integrated_keys, dict):
-            integrated_keys_enabled = integrated_keys.get("enabled", False)
-        else:
-            integrated_keys_enabled = bool(integrated_keys)
-
-        deployment_table.add_row(
-            "[bold]Managed Keys:[/bold]",
-            "[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]"
@@ -346,6 +332,7 @@ async def status(
 @with_deploy_config
 async def sessions(
     deploy_config=typer.Option(None, hidden=True),
+    config_file: Optional[str] = CONFIG_FILE_OPTION,
     agent_name: str = typer.Argument(
         None, help="Name of the agent to list sessions for e.g. 'my-agent'", show_default=False
     ),
@@ -781,6 +768,7 @@ async def deployments(
 @with_deploy_config
 async def start(
     deploy_config=typer.Option(None, hidden=True),
+    config_file: Optional[str] = CONFIG_FILE_OPTION,
     agent_name: str = typer.Argument(None, help="Name of the agent to start e.g. 'my-agent'"),
     force: bool = typer.Option(
         False,
@@ -947,6 +935,7 @@ async def start(
 @with_deploy_config
 async def stop(
     deploy_config=typer.Option(None, hidden=True),
+    config_file: Optional[str] = CONFIG_FILE_OPTION,
     agent_name: str = typer.Argument(None, help="Name of the agent e.g. 'my-agent'"),
     session_id: str = typer.Option(
         ...,

{pipecatcloud-0.3.1 → pipecatcloud-0.4.0}/src/pipecatcloud/cli/commands/deploy.py

@@ -28,6 +28,7 @@ from pipecatcloud._utils.build_utils import (
 )
 from pipecatcloud._utils.console_utils import console
 from pipecatcloud._utils.deploy_utils import (
+    CONFIG_FILE_OPTION,
     BuildConfig,
     DeployConfigParams,
     KrispVivaConfig,
@@ -482,6 +483,7 @@ def create_deploy_command(app: typer.Typer):
     @with_deploy_config
     async def deploy(
         deploy_config=typer.Option(None, hidden=True),
+        config_file: Optional[str] = CONFIG_FILE_OPTION,
         agent_name: str = typer.Argument(
             None, help="Name of the agent to deploy e.g. 'my-agent'", show_default=False
         ),
@@ -534,12 +536,6 @@ def create_deploy_command(app: typer.Typer):
             help="[DEPRECATED] Enable Krisp integration for this deployment. Use --krisp-viva-audio-filter instead",
             rich_help_panel="Deployment Configuration",
         ),
-        managed_keys: bool = typer.Option(
-            False,
-            "--enable-managed-keys",
-            help="Enable Managed Keys for this deployment",
-            rich_help_panel="Deployment Configuration",
-        ),
         krisp_viva_audio_filter: str = typer.Option(
             None,
             "--krisp-viva-audio-filter",
@@ -656,7 +652,6 @@ def create_deploy_command(app: typer.Typer):
             max_agents=max_agents if max_agents is not None else partial_config.scaling.max_agents,
         )
         partial_config.enable_krisp = krisp or partial_config.enable_krisp
-        partial_config.enable_managed_keys = managed_keys or partial_config.enable_managed_keys
         partial_config.agent_profile = profile or partial_config.agent_profile
 
         # Override build config from CLI args
@@ -797,7 +792,6 @@ def create_deploy_command(app: typer.Typer):
                 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 (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]",
             ]
         )

{pipecatcloud-0.3.1 → pipecatcloud-0.4.0}/src/pipecatcloud/cli/commands/docker.py

@@ -13,7 +13,11 @@ from rich.panel import Panel
 
 from pipecatcloud._utils.async_utils import synchronizer
 from pipecatcloud._utils.console_utils import console
-from pipecatcloud._utils.deploy_utils import DeployConfigParams, with_deploy_config
+from pipecatcloud._utils.deploy_utils import (
+    CONFIG_FILE_OPTION,
+    DeployConfigParams,
+    with_deploy_config,
+)
 from pipecatcloud.cli import PIPECAT_CLI_NAME
 
 docker_cli = typer.Typer(
@@ -180,6 +184,7 @@ def _build_image_name(
 @with_deploy_config
 async def build_push(
     deploy_config=typer.Option(None, hidden=True),
+    config_file: Optional[str] = CONFIG_FILE_OPTION,
     agent_name: str = typer.Argument(
         None, help="Name of the agent to build image for e.g. 'my-agent'", show_default=False
     ),

{pipecatcloud-0.3.1 → pipecatcloud-0.4.0}/src/pipecatcloud/cli/config.py

@@ -62,7 +62,11 @@ def _read_user_config():
                         stacklevel=2,
                     )
         if config_problem:
-            raise ConfigError(config_problem)
+            warnings.warn(
+                f"{config_problem} Run `pcc auth login` to fix.",
+                stacklevel=2,
+            )
+            return {}
 
     return config_data
 

{pipecatcloud-0.3.1 → pipecatcloud-0.4.0}/src/pipecatcloud/cli/entry_point.py

@@ -35,11 +35,12 @@ def version_callback(value: bool):
         raise typer.Exit()
 
 
-def config_callback(value: bool):
+def show_config_callback(value: bool):
     if value:
         from rich.pretty import pprint
 
         from pipecatcloud._utils.deploy_utils import load_deploy_config_file
+        from pipecatcloud.cli.config import deploy_config_path
 
         # Print local config
         pprint(config.to_dict())
@@ -48,11 +49,11 @@ def config_callback(value: bool):
         try:
             deploy_config = load_deploy_config_file()
             if deploy_config:
-                console.print("Deploy config [dim](pcc-deploy.toml)[/dim]:")
+                console.print(f"Deploy config [dim]({deploy_config_path})[/dim]:")
                 console.print_json(data=deploy_config.to_dict())
         except ConfigFileError as e:
             console.error(
-                f"Malformed pcc-deploy.toml - Please correct errors and try again.\n\n{e}"
+                f"Malformed {deploy_config_path} - Please correct errors and try again.\n\n{e}"
             )
 
         raise typer.Exit()
@@ -71,7 +72,12 @@ entrypoint_cli_typer = typer.Typer(
 def cli(
     ctx: typer.Context,
     _version: bool = typer.Option(None, "--version", callback=version_callback, help="CLI version"),
-    _config: bool = typer.Option(None, "--config", callback=config_callback, help="CLI config"),
+    _show_cli_config: bool = typer.Option(
+        None,
+        "--show-cli-config",
+        callback=show_config_callback,
+        help="Show CLI internal configuration (credentials, active org)",
+    ),
 ):
     pass
 

{pipecatcloud-0.3.1 → pipecatcloud-0.4.0}/src/pipecatcloud.egg-info/PKG-INFO

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

{pipecatcloud-0.3.1 → pipecatcloud-0.4.0}/src/pipecatcloud.egg-info/SOURCES.txt

@@ -51,11 +51,12 @@ src/pipecatcloud/cli/commands/regions.py
 src/pipecatcloud/cli/commands/secrets.py
 src/pipecatcloud/smallwebrtc/session_manager.py
 tests/__init__.py
+tests/conftest.py
 tests/test_agent_sessions.py
 tests/test_agent_stop.py
 tests/test_api_client.py
+tests/test_config_file.py
 tests/test_deployment_status.py
 tests/test_docker_commands.py
 tests/test_krisp_viva.py
-tests/test_managed_keys.py
 tests/test_regions.py

pipecatcloud-0.4.0/tests/conftest.py

@@ -0,0 +1,17 @@
+"""
+Global test fixtures.
+
+Sets PIPECAT_CONFIG_PATH to an isolated temp file so tests never
+read or corrupt the real user credentials. Provides a fake token
+and org so @requires_login passes through.
+"""
+
+import os
+import tempfile
+
+# Must be set before any pipecatcloud module is imported, since
+# config.py reads the credentials file at module load time.
+_tmp = tempfile.NamedTemporaryFile(suffix=".toml", delete=False, mode="w")
+_tmp.write('token = "test-token"\norg = "test-org"\n')
+_tmp.close()
+os.environ["PIPECAT_CONFIG_PATH"] = _tmp.name

{pipecatcloud-0.3.1 → pipecatcloud-0.4.0}/tests/test_api_client.py

@@ -260,7 +260,6 @@ class TestAPIRegionWithOtherParameters:
             region="ap",
             secret_set="my-secrets",
             image_credentials="my-creds",
-            enable_managed_keys=True,
         )
 
         with patch.object(api_client, "_base_request", new_callable=AsyncMock) as mock_request:
@@ -274,7 +273,6 @@ class TestAPIRegionWithOtherParameters:
             assert payload["region"] == "ap"
             assert payload["secretSet"] == "my-secrets"
             assert payload["imagePullSecretSet"] == "my-creds"
-            assert payload["enableIntegratedKeysProxy"] is True
 
 
 class TestAPIProperties:

pipecatcloud-0.4.0/tests/test_config_file.py

@@ -0,0 +1,48 @@
+"""
+Unit tests for the --config-file flag behavior via @with_deploy_config.
+"""
+
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+import typer
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from pipecatcloud._utils.deploy_utils import with_deploy_config
+
+
+@with_deploy_config
+def dummy_command(deploy_config=None, config_file=None):
+    """Minimal command decorated with @with_deploy_config."""
+    return deploy_config
+
+
+class TestConfigFileFlag:
+    """Test --config-file override behavior in @with_deploy_config."""
+
+    def test_loads_alternate_config_file(self):
+        """--config-file should load the specified file instead of the default."""
+        with tempfile.NamedTemporaryFile(suffix=".toml", mode="w", delete=False) as f:
+            f.write('agent_name = "alt-agent"\n')
+            f.flush()
+            try:
+                result = dummy_command(config_file=f.name)
+                assert result is not None
+                assert result.agent_name == "alt-agent"
+            finally:
+                os.unlink(f.name)
+
+    def test_nonexistent_config_file_exits(self):
+        """--config-file pointing to missing file should exit with error."""
+        with pytest.raises(typer.Exit):
+            dummy_command(config_file="/nonexistent/path.toml")
+
+    def test_no_config_file_uses_default(self):
+        """Without --config-file, falls back to default pcc-deploy.toml behavior."""
+        result = dummy_command(config_file=None)
+        # No pcc-deploy.toml in test dir, so deploy_config should be None
+        assert result is None

{pipecatcloud-0.3.1 → pipecatcloud-0.4.0}/tests/test_krisp_viva.py

@@ -132,7 +132,6 @@ class TestDeployConfigIntegration:
             agent_name="test-agent",
             image="test:latest",
             enable_krisp=True,
-            enable_managed_keys=True,
             krisp_viva=KrispVivaConfig(audio_filter="tel"),
         )
 
@@ -143,7 +142,6 @@ class TestDeployConfigIntegration:
         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"
 
 
@@ -237,7 +235,6 @@ class TestTOMLConfiguration:
         agent_name = "test-agent"
         image = "test:latest"
         enable_krisp = true
-        enable_managed_keys = true
         secret_set = "my-secrets"
 
         [scaling]
@@ -257,7 +254,6 @@ class TestTOMLConfiguration:
         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
@@ -550,7 +546,6 @@ class TestBackwardCompatibility:
         agent_name = "legacy-agent"
         image = "legacy:latest"
         enable_krisp = true
-        enable_managed_keys = true
 
         [scaling]
         min_agents = 1
@@ -569,7 +564,6 @@ class TestBackwardCompatibility:
         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
 
 
@@ -612,13 +606,12 @@ class TestErrorHandling:
         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."""
+        """Krisp and Krisp VIVA can 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"),
         )
 
@@ -627,7 +620,6 @@ class TestErrorHandling:
 
         # Assert
         assert result["enable_krisp"] is True
-        assert result["enable_managed_keys"] is True
         assert result["krisp_viva"]["audio_filter"] == "pro"
 
 

pipecatcloud-0.3.1/tests/test_managed_keys.py

@@ -1,426 +0,0 @@
-"""
-Unit tests for managed keys feature.
-
-Tests follow AAA pattern and focus on behaviors/outcomes rather than implementation details.
-Covers data model, TOML parsing, CLI commands, and API integration.
-"""
-
-from unittest.mock import AsyncMock, patch
-
-import pytest
-
-# Import from source, not installed package
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
-
-from pipecatcloud._utils.deploy_utils import DeployConfigParams, load_deploy_config_file
-from pipecatcloud.api import _API
-
-
-class TestDeployConfigDataModel:
-    """Test the DeployConfigParams data model with managed keys support."""
-
-    def test_default_keys_is_disabled(self):
-        """When not specified, managed keys should default to disabled."""
-        # Arrange & Act
-        config = DeployConfigParams()
-
-        # Assert
-        assert config.enable_managed_keys is False
-
-    def test_can_enable_keys(self):
-        """Integrated keys can be explicitly enabled."""
-        # Arrange & Act
-        config = DeployConfigParams(enable_managed_keys=True)
-
-        # Assert
-        assert config.enable_managed_keys is True
-
-    def test_keys_included_in_dict_representation(self):
-        """Dictionary representation should include managed keys setting."""
-        # Arrange
-        config = DeployConfigParams(agent_name="test-agent", enable_managed_keys=True)
-
-        # Act
-        result = config.to_dict()
-
-        # Assert
-        assert "enable_managed_keys" in result
-        assert result["enable_managed_keys"] is True
-
-    def test_keys_preserves_other_settings(self):
-        """Adding managed keys should not affect other configuration settings."""
-        # Arrange
-        config = DeployConfigParams(
-            agent_name="test-agent",
-            image="test:latest",
-            enable_krisp=True,
-            enable_managed_keys=True,
-        )
-
-        # 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
-
-
-class TestTOMLConfiguration:
-    """Test TOML configuration file parsing with managed keys."""
-
-    @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_keys_proxy_from_toml_when_enabled(self, temp_config_file):
-        """TOML file with managed keys enabled should be parsed correctly."""
-        # Arrange
-        config_content = """
-        agent_name = "test-agent"
-        image = "test:latest"
-        enable_managed_keys = true
-        """
-        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.enable_managed_keys is True
-
-    def test_loads_keys_proxy_from_toml_when_disabled(self, temp_config_file):
-        """TOML file with managed keys explicitly disabled should be parsed correctly."""
-        # Arrange
-        config_content = """
-        agent_name = "test-agent"
-        image = "test:latest"
-        enable_managed_keys = false
-        """
-        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.enable_managed_keys is False
-
-    def test_defaults_keys_proxy_when_not_in_toml(self, temp_config_file):
-        """TOML file without managed keys setting 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.enable_managed_keys is False
-
-    def test_preserves_other_settings_with_keys_proxy(self, temp_config_file):
-        """Keys proxy 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
-        """
-        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
-
-
-class TestAPIIntegration:
-    """Test API client integration with managed keys."""
-
-    @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_keys_proxy(self, api_client):
-        """Deploy payload should include enableIntegratedKeys field."""
-        # Arrange
-        config = DeployConfigParams(
-            agent_name="test-agent", image="test:latest", enable_managed_keys=True
-        )
-
-        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 "enableIntegratedKeysProxy" in payload
-            assert payload["enableIntegratedKeysProxy"] is True
-
-    @pytest.mark.asyncio
-    async def test_update_payload_includes_keys_proxy(self, api_client):
-        """Update payload should include enableIntegratedKeys field."""
-        # Arrange
-        config = DeployConfigParams(
-            agent_name="test-agent", image="test:latest", enable_managed_keys=True
-        )
-
-        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 "enableIntegratedKeysProxy" in payload
-            assert payload["enableIntegratedKeysProxy"] is True
-
-    @pytest.mark.asyncio
-    async def test_disabled_keys_proxy_sends_false(self, api_client):
-        """When managed keys is disabled, API should send false value."""
-        # Arrange
-        config = DeployConfigParams(
-            agent_name="test-agent", image="test:latest", enable_managed_keys=False
-        )
-
-        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 "enableIntegratedKeysProxy" in payload
-            assert payload["enableIntegratedKeysProxy"] is False
-
-
-class TestAgentStatusDisplay:
-    """Test agent status command displays managed keys status."""
-
-    @pytest.fixture
-    def mock_api(self):
-        """Mock the API agent method."""
-        with patch("pipecatcloud.cli.commands.agent.API") as mock_api:
-            yield mock_api
-
-    def test_displays_enabled_keys_proxy(self, mock_api, capsys):
-        """Agent status should display when managed keys is enabled."""
-        # Arrange
-        from pipecatcloud.cli.commands.agent import status
-
-        mock_api.agent = AsyncMock(
-            return_value=(
-                {
-                    "ready": True,
-                    "deployment": {
-                        "manifest": {"spec": {"integratedKeysProxy": {"enabled": True}}}
-                    },
-                    "autoScaling": {
-                        "minReplicas": 0,
-                        "maxReplicas": 1,
-                    },  # Avoid undefined variable bug
-                },
-                None,
-            )
-        )
-
-        # Act
-        status(agent_name="test-agent", organization="test-org")
-
-        # Assert
-        captured = capsys.readouterr()
-        assert "Managed Keys" in captured.out
-        assert "Enabled" in captured.out
-
-    def test_displays_disabled_keys_proxy(self, mock_api, capsys):
-        """Agent status should display when managed keys is disabled."""
-        # Arrange
-        from pipecatcloud.cli.commands.agent import status
-
-        mock_api.agent = AsyncMock(
-            return_value=(
-                {
-                    "ready": True,
-                    "deployment": {"manifest": {"spec": {}}},
-                    "autoScaling": {
-                        "minReplicas": 0,
-                        "maxReplicas": 1,
-                    },  # Avoid undefined variable bug
-                },
-                None,
-            )
-        )
-
-        # Act
-        status(agent_name="test-agent", organization="test-org")
-
-        # Assert
-        captured = capsys.readouterr()
-        assert "Managed Keys" in captured.out
-        assert "Disabled" in captured.out
-
-    def test_handles_boolean_keys_proxy_value(self, mock_api, capsys):
-        """Agent status should handle boolean value for backward compatibility."""
-        # Arrange
-        from pipecatcloud.cli.commands.agent import status
-
-        mock_api.agent = AsyncMock(
-            return_value=(
-                {
-                    "ready": True,
-                    "deployment": {"manifest": {"spec": {"integratedKeysProxy": True}}},
-                    "autoScaling": {
-                        "minReplicas": 0,
-                        "maxReplicas": 1,
-                    },  # Avoid undefined variable bug
-                },
-                None,
-            )
-        )
-
-        # Act
-        status(agent_name="test-agent", organization="test-org")
-
-        # Assert
-        captured = capsys.readouterr()
-        assert "Managed Keys" in captured.out
-        assert "Enabled" in captured.out
-
-
-class TestBackwardCompatibility:
-    """Test backward compatibility with existing deployments."""
-
-    def test_existing_config_without_keys_proxy_works(self):
-        """Existing configs without managed keys 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["enable_managed_keys"] is False
-
-    def test_api_response_without_keys_proxy_doesnt_crash(self):
-        """Agent status should handle API responses without managed keys field."""
-        # Arrange
-        data = {"ready": True, "deployment": {"manifest": {"spec": {"image": "test:latest"}}}}
-
-        # Act - simulate the logic from agent.py
-        integrated_keys = (
-            data.get("deployment", {})
-            .get("manifest", {})
-            .get("spec", {})
-            .get("integratedKeysProxy", {})
-        )
-        if isinstance(integrated_keys, dict):
-            keys_proxy_enabled = integrated_keys.get("enabled", False)
-        else:
-            keys_proxy_enabled = bool(integrated_keys)
-
-        # Assert
-        assert keys_proxy_enabled is False
-
-    @pytest.fixture
-    def temp_legacy_config(self, tmp_path):
-        """Create a legacy TOML config without managed keys."""
-        config_path = tmp_path / "pcc-deploy.toml"
-        config_content = """
-        agent_name = "legacy-agent"
-        image = "legacy:latest"
-        enable_krisp = true
-        
-        [scaling]
-        min_instances = 1
-        max_instances = 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 managed keys 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 False
-        assert config.scaling.min_agents == 1  # Converted from min_instances
-
-
-class TestErrorHandling:
-    """Test error handling and edge cases."""
-
-    @pytest.mark.asyncio
-    async def test_api_error_during_deploy_with_keys_proxy(self):
-        """API errors during deployment should be handled properly."""
-        # Arrange
-        api = _API(token="test-token", is_cli=True)
-        config = DeployConfigParams(
-            agent_name="test-agent", image="test:latest", enable_managed_keys=True
-        )
-
-        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_keys_proxy(self):
-        """Both Krisp and Keys Proxy can be enabled simultaneously."""
-        # Arrange
-        config = DeployConfigParams(
-            agent_name="test-agent",
-            image="test:latest",
-            enable_krisp=True,
-            enable_managed_keys=True,
-        )
-
-        # Act
-        result = config.to_dict()
-
-        # Assert
-        assert result["enable_krisp"] is True
-        assert result["enable_managed_keys"] is True