pipecatcloud 0.2.4__tar.gz → 0.2.5__tar.gz

pipecatcloud-0.2.4/.github/workflows/publish-test.yml → pipecatcloud-0.2.5/.github/workflows/publish-pypi.yml

@@ -1,61 +1,67 @@
-name: Publish to TEST PyPI
+name: Publish to PyPI
 
 on:
   workflow_dispatch:
     inputs:
-      version:
-        description: 'Version to publish (must match pyproject.toml, e.g. 0.0.4)'
-        required: true
+      gitref:
         type: string
+        description: 'what git tag to build (e.g. v0.0.74)'
+        required: true
 
 jobs:
   build:
     name: 'Build and upload wheels'
     runs-on: ubuntu-latest
-    permissions:
-      contents: write
     steps:
-      - name: Checkout code
+      - name: Checkout repo
         uses: actions/checkout@v4
         with:
-          fetch-tags: true
-          fetch-depth: 100
+          ref: ${{ github.event.inputs.gitref }}
 
       - name: Install uv
         uses: astral-sh/setup-uv@v3
         with:
           version: 'latest'
-
       - name: Set up Python
         run: uv python install 3.12
-
-      - name: Verify version matches
-        run: |
-          PROJECT_VERSION=$(uv run python -c "import tomllib; print(tomllib.load(open('pyproject.toml', 'rb'))['project']['version'])")
-          if [ "$PROJECT_VERSION" != "${{ github.event.inputs.version }}" ]; then
-            echo "Error: Input version (${{ github.event.inputs.version }}) does not match pyproject.toml version ($PROJECT_VERSION)"
-            exit 1
-          fi
-
       - name: Install development dependencies
         run: uv sync --group dev
-
       - name: Build project
         run: uv build
-
       - name: Upload wheels
         uses: actions/upload-artifact@v4
         with:
           name: wheels
           path: ./dist
 
+  publish-to-pypi:
+    name: 'Publish to PyPI'
+    runs-on: ubuntu-latest
+    needs: [build]
+    environment:
+      name: pypi
+      url: https://pypi.org/p/pipecatcloud
+    permissions:
+      id-token: write
+    steps:
+      - name: Download wheels
+        uses: actions/download-artifact@v4
+        with:
+          name: wheels
+          path: ./dist
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verbose: true
+          print-hash: true
+
   publish-to-test-pypi:
     name: 'Publish to Test PyPI'
     runs-on: ubuntu-latest
     needs: [build]
     environment:
       name: testpypi
-      url: https://test.pypi.org/project/pipecat-cloud
+      url: https://test.pypi.org/p/pipecatcloud
     permissions:
       id-token: write
     steps:
@@ -64,10 +70,9 @@ jobs:
         with:
           name: wheels
           path: ./dist
-
-      - name: Publish to TestPyPI
+      - name: Publish to Test PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
-          repository-url: https://test.pypi.org/legacy/
           verbose: true
           print-hash: true
+          repository-url: https://test.pypi.org/legacy/

pipecatcloud-0.2.5/.github/workflows/publish-test.yml

@@ -0,0 +1,51 @@
+name: Publish to TEST PyPI
+
+on: workflow_dispatch
+
+jobs:
+  build:
+    name: 'Build and upload wheels'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+        with:
+          fetch-tags: true
+          fetch-depth: 100
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: 'latest'
+      - name: Set up Python
+        run: uv python install 3.12
+      - name: Install development dependencies
+        run: uv sync --group dev
+      - name: Build project
+        run: uv build
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels
+          path: ./dist
+
+  publish-to-test-pypi:
+    name: 'Publish to Test PyPI'
+    runs-on: ubuntu-latest
+    needs: [build]
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/pipecatcloud
+    permissions:
+      id-token: write
+    steps:
+      - name: Download wheels
+        uses: actions/download-artifact@v4
+        with:
+          name: wheels
+          path: ./dist
+      - name: Publish to Test PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verbose: true
+          print-hash: true
+          repository-url: https://test.pypi.org/legacy/

{pipecatcloud-0.2.4 → pipecatcloud-0.2.5}/CHANGELOG.md

@@ -5,6 +5,23 @@ 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.5] - 2025-10-02
+
+### Added
+
+- Added a `body` parameter to the fallback type, `WebsocketRunnerArguments`.
+
+- Added `SmallWebRTCSessionManager`, a Session Manager to simplify bot creation
+  in Pipecat Cloud using `SmallWebRTCTransport`.
+- Added a `SmallWebRTCSessionArguments` dataclass.
+
+- `deploy` command now accepts a `--enable-managed-keys` flag which enables
+  properly configured agents to use Daily's API keys for supported upstream
+  services. This can also be enabled via `pcc-deploy.toml` by adding the
+  `enable_managed_keys` attribute and a boolean value.
+
+- `agent status` now reflects the state of the managed keys feature.
+
 ## [0.2.4] - 2025-08-26
 
 ### Added

{pipecatcloud-0.2.4/src/pipecatcloud.egg-info → pipecatcloud-0.2.5}/PKG-INFO

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

{pipecatcloud-0.2.4 → pipecatcloud-0.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pipecatcloud"
-version = "0.2.4"
+dynamic = ["version"]
 requires-python = ">=3.10"
 description = "Cloud hosting for Pipecat AI applications"
 license = { text = "BSD 2-Clause License" }
@@ -58,3 +58,7 @@ line-length = 100
 
 [project.urls]
 Website = "https://docs.pipecat.daily.co/"
+
+[tool.setuptools_scm]
+local_scheme = "no-local-version"
+fallback_version = "0.0.0-dev"

{pipecatcloud-0.2.4 → pipecatcloud-0.2.5}/src/pipecatcloud/__init__.py

@@ -13,6 +13,7 @@ from pipecatcloud.agent import (
     DailySessionArguments,
     PipecatSessionArguments,
     SessionArguments,
+    SmallWebRTCRunnerArguments,
     WebSocketSessionArguments,
 )
 from pipecatcloud.exception import (
@@ -25,6 +26,7 @@ from pipecatcloud.exception import (
     InvalidError,
 )
 from pipecatcloud.session import Session, SessionParams
+from pipecatcloud.smallwebrtc.session_manager import SmallWebRTCSessionManager
 
 logger.remove()
 logger.add(sys.stderr, level=str(os.getenv("PCC_LOG_LEVEL", "INFO")))
@@ -35,10 +37,12 @@ __all__ = [
     "DailySessionArguments",
     "PipecatSessionArguments",
     "SessionArguments",
+    "SmallWebRTCRunnerArguments",
     "WebSocketSessionArguments",
     # Session classes
     "Session",
     "SessionParams",
+    "SmallWebRTCSessionManager",
     # Exception classes
     "AgentNotHealthyError",
     "AgentStartError",

{pipecatcloud-0.2.4 → pipecatcloud-0.2.5}/src/pipecatcloud/_utils/deploy_utils.py

@@ -64,6 +64,7 @@ class DeployConfigParams:
     secret_set: Optional[str] = None
     scaling: ScalingParams = ScalingParams()
     enable_krisp: bool = False
+    enable_managed_keys: bool = False
     docker_config: dict = field(factory=dict)
 
     def __attrs_post_init__(self):
@@ -78,6 +79,7 @@ class DeployConfigParams:
             "secret_set": self.secret_set,
             "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,
         }
 
@@ -117,6 +119,7 @@ def load_deploy_config_file() -> Optional[DeployConfigParams]:
             "secret_set",
             "scaling",
             "enable_krisp",
+            "enable_managed_keys",
             "docker",
         }
         unexpected_keys = set(config_data.keys()) - expected_keys

{pipecatcloud-0.2.4 → pipecatcloud-0.2.5}/src/pipecatcloud/agent.py

@@ -16,6 +16,7 @@ try:
         DailyRunnerArguments,
         RunnerArguments,
         WebSocketRunnerArguments,
+        SmallWebRTCRunnerArguments,
     )
 
     _PIPECAT_RUNNER_TYPES_AVAILABLE = True
@@ -62,6 +63,17 @@ except ImportError:
         """
 
         websocket: WebSocket
+        body: Any
+
+    @dataclass
+    class SmallWebRTCRunnerArguments(RunnerArguments):
+        """Fallback Small WebRTC transport session arguments for the runner.
+
+        Parameters:
+            webrtc_connection: Pre-configured WebRTC peer connection
+        """
+
+        webrtc_connection: Any
 
 
 def _warn_standalone_usage():
@@ -131,3 +143,17 @@ class WebSocketSessionArguments(WebSocketRunnerArguments, SessionArguments):
     def __post_init__(self):
         WebSocketRunnerArguments.__post_init__(self)
         _warn_standalone_usage()
+
+@dataclass
+class SmallWebRTCSessionArguments(SmallWebRTCRunnerArguments, SessionArguments):
+    """SmallWebRTCTransport based agent session arguments.
+
+    Inherits from SmallWebRTCRunnerArguments for compatibility with pipecat-ai runner.
+    When pipecat-ai is not installed, uses a fallback implementation (deprecated).
+
+    For best compatibility, install: pip install pipecatcloud[pipecat]
+    """
+
+    def __post_init__(self):
+        SmallWebRTCRunnerArguments.__post_init__(self)
+        _warn_standalone_usage()

{pipecatcloud-0.2.4 → pipecatcloud-0.2.5}/src/pipecatcloud/api.py

@@ -321,6 +321,7 @@ class _API:
                 "maxAgents": deploy_config.scaling.max_agents,
             },
             "enableKrisp": deploy_config.enable_krisp,
+            "enableIntegratedKeysProxy": deploy_config.enable_managed_keys,  # API expects this field name
         }
 
         # Remove None values recursively

{pipecatcloud-0.2.4 → pipecatcloud-0.2.5}/src/pipecatcloud/cli/commands/agent.py

@@ -5,7 +5,6 @@
 #
 
 import json
-import statistics
 from enum import Enum
 
 import aiohttp
@@ -132,6 +131,19 @@ async def status(
             "[bold]Updated At:[/bold]",
             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]",
+        )
 
         # Autoscaling info
         autoscaling_data = data.get("autoScaling", None)

{pipecatcloud-0.2.4 → pipecatcloud-0.2.5}/src/pipecatcloud/cli/commands/deploy.py

@@ -279,6 +279,12 @@ def create_deploy_command(app: typer.Typer):
             help="Enable Krisp integration for this deployment",
             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",
+        ),
         skip_confirm: bool = typer.Option(
             False,
             "--force",
@@ -345,6 +351,7 @@ def create_deploy_command(app: typer.Typer):
             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
 
         # Assert agent name and image are provided
         if not partial_config.agent_name:
@@ -382,6 +389,7 @@ 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]Krisp:[/bold white] {'[dim]Disabled[/dim]' if not partial_config.enable_krisp else '[green]Enabled[/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.5/src/pipecatcloud/smallwebrtc/session_manager.py

@@ -0,0 +1,87 @@
+import asyncio
+from typing import Optional
+
+
+class SmallWebRTCSessionManager:
+    """
+    Manages the waiting logic between PipecatSession and SmallWebRTCSession.
+
+    This class provides:
+      - A mechanism to wait for a WebRTC connection within a timeout period.
+      - Automatic cancellation if no connection is established in time.
+      - A way to complete the waiting future once the session has successfully started.
+    """
+
+    def __init__(self, timeout_seconds: int = 120):
+        self._pending_future: Optional[asyncio.Future] = None
+        self._timeout_task: Optional[asyncio.Task] = None
+        self._timeout_seconds = timeout_seconds
+
+    async def wait_for_webrtc(self) -> None:
+        """
+        Creates and waits for a future to be completed when WebRTC connection arrives.
+
+        Raises:
+            TimeoutError: If WebRTC connection is not received within the timeout period
+            RuntimeError: If another waiting operation is already in progress
+        """
+        if self._pending_future is not None:
+            raise RuntimeError("Already waiting for WebRTC connection")
+
+        self._pending_future = asyncio.Future()
+
+        async def timeout_handler():
+            await asyncio.sleep(self._timeout_seconds)
+            if self._pending_future and not self._pending_future.done():
+                self._pending_future.set_exception(
+                    TimeoutError(f"WebRTC connection not received within {self._timeout_seconds} seconds")
+                )
+
+        # Create and store the timeout task
+        self._timeout_task = asyncio.create_task(timeout_handler())
+
+        try:
+            await self._pending_future
+        finally:
+            self._cleanup()
+
+    def complete_session(self) -> bool:
+        """
+        Completes the waiting future.
+
+        Returns:
+            bool: True if the future was found and completed, False otherwise
+        """
+        if self._pending_future and not self._pending_future.done():
+            # Cancel the timeout task first
+            self.cancel_timeout()
+            # Complete the future
+            self._pending_future.set_result(True)
+            return True
+        return False
+
+    def cancel_timeout(self) -> bool:
+        """
+        Cancels the timeout handler without completing the future.
+
+        Returns:
+            bool: True if the timeout task was found and cancelled, False otherwise
+        """
+        if self._timeout_task and not self._timeout_task.done():
+            self._timeout_task.cancel()
+            return True
+        return False
+
+    def _cleanup(self) -> None:
+        """Cleans up all resources."""
+        self._pending_future = None
+        self._timeout_task = None
+
+    def is_waiting(self) -> bool:
+        """
+        Checks if currently waiting for WebRTC connection.
+
+        Returns:
+            bool: True if waiting for connection, False otherwise
+        """
+        return self._pending_future is not None and not self._pending_future.done()

{pipecatcloud-0.2.4 → pipecatcloud-0.2.5/src/pipecatcloud.egg-info}/PKG-INFO

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

{pipecatcloud-0.2.4 → pipecatcloud-0.2.5}/src/pipecatcloud.egg-info/SOURCES.txt

@@ -7,7 +7,6 @@ pyproject.toml
 pytest.ini
 .github/workflows/publish-pypi.yml
 .github/workflows/publish-test.yml
-.github/workflows/python-publish.yml
 .github/workflows/tests.yml
 src/pipecatcloud/__init__.py
 src/pipecatcloud/__main__.py
@@ -43,6 +42,8 @@ src/pipecatcloud/cli/commands/init.py
 src/pipecatcloud/cli/commands/organizations.py
 src/pipecatcloud/cli/commands/run.py
 src/pipecatcloud/cli/commands/secrets.py
+src/pipecatcloud/smallwebrtc/session_manager.py
 tests/__init__.py
 tests/test_agent_sessions.py
-tests/test_docker_commands.py
+tests/test_docker_commands.py
+tests/test_managed_keys.py

pipecatcloud-0.2.5/tests/test_managed_keys.py

@@ -0,0 +1,437 @@
+"""
+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.
+"""
+
+import json
+import tempfile
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+import toml
+
+from src.pipecatcloud._utils.deploy_utils import DeployConfigParams, load_deploy_config_file
+from src.pipecatcloud.api import _API
+from src.pipecatcloud.exception import ConfigFileError
+
+
+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("src.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 src.pipecatcloud.cli.commands.agent import status
+        
+        mock_api.agent = AsyncMock(return_value=({
+            "ready": True,
+            "deployment": {
+                "manifest": {
+                    "spec": {
+                        "integratedKeysProxy": {
+                            "enabled": True
+                        }
+                    }
+                }
+            },
+            "autoScaling": {"minAgents": 0, "maxAgents": 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 src.pipecatcloud.cli.commands.agent import status
+        
+        mock_api.agent = AsyncMock(return_value=({
+            "ready": True,
+            "deployment": {
+                "manifest": {
+                    "spec": {}
+                }
+            },
+            "autoScaling": {"minAgents": 0, "maxAgents": 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 src.pipecatcloud.cli.commands.agent import status
+        
+        mock_api.agent = AsyncMock(return_value=({
+            "ready": True,
+            "deployment": {
+                "manifest": {
+                    "spec": {
+                        "integratedKeysProxy": True
+                    }
+                }
+            },
+            "autoScaling": {"minAgents": 0, "maxAgents": 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

pipecatcloud-0.2.4/.github/workflows/publish-pypi.yml

@@ -1,84 +0,0 @@
-name: Publish to PyPI
-
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: 'Version to publish (must match pyproject.toml, e.g. 0.0.4)'
-        required: true
-        type: string
-
-jobs:
-  build:
-    name: 'Build and upload wheels'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          fetch-tags: true
-          fetch-depth: 100
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v3
-        with:
-          version: 'latest'
-
-      - name: Set up Python
-        run: uv python install 3.12
-
-      - name: Verify version matches
-        run: |
-          PROJECT_VERSION=$(uv run python -c "import tomllib; print(tomllib.load(open('pyproject.toml', 'rb'))['project']['version'])")
-          if [ "$PROJECT_VERSION" != "${{ github.event.inputs.version }}" ]; then
-            echo "Error: Input version (${{ github.event.inputs.version }}) does not match pyproject.toml version ($PROJECT_VERSION)"
-            exit 1
-          fi
-
-      - name: Install development dependencies
-        run: uv sync --group dev
-
-      - name: Build project
-        run: uv build
-
-      - name: Upload wheels
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels
-          path: ./dist
-
-  publish-to-pypi:
-    name: 'Publish to PyPI'
-    runs-on: ubuntu-latest
-    needs: [build]
-    environment:
-      name: pypi
-      url: https://pypi.org/p/pipecat-cloud
-    permissions:
-      id-token: write
-      contents: write # Needed for tagging
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          fetch-tags: true
-          fetch-depth: 100
-
-      - name: Create release tag
-        run: |
-          git config --local user.email "action@github.com"
-          git config --local user.name "GitHub Action"
-          git tag -a "v${{ github.event.inputs.version }}" -m "Version ${{ github.event.inputs.version }}"
-          git push origin "v${{ github.event.inputs.version }}"
-
-      - name: Download wheels
-        uses: actions/download-artifact@v4
-        with:
-          name: wheels
-          path: ./dist
-
-      - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          verbose: true
-          print-hash: true

pipecatcloud-0.2.4/.github/workflows/python-publish.yml

@@ -1,40 +0,0 @@
-name: Build and publish Python package
-
-on:
-  release:
-    types: [published]
-
-permissions:
-  contents: read
-
-jobs:
-  release-build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.10'
-      - name: Setup virtual environment
-        run: |
-          python -m venv .venv
-      - name: Install basic Python dependencies
-        run: |
-          source .venv/bin/activate
-          python -m pip install --upgrade pip
-          pip install -r dev-requirements.txt
-      - name: Build project
-        run: |
-          source .venv/bin/activate
-          python -m build
-      - name: Install project and other Python dependencies
-        run: |
-          source .venv/bin/activate
-          pip install --editable .
-      - name: Upload distributions
-        uses: actions/upload-artifact@v4
-        with:
-          name: release-dists
-          path: dist/