pipecatcloud 0.2.5__tar.gz → 0.2.7__tar.gz

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

@@ -5,6 +5,36 @@ 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.7] - 2025-10-21
+
+### Added
+
+- Added a `stop` command to `pcc agent` that allows stopping an ongoing Pipecat
+  Cloud session.
+
+### Changed
+
+- Fallback `RunnerArguments` now include a `body` field in the base class.
+
+### Deprecated
+
+- The `pcc init` command is now deprecated and will be removed in a future
+  version. Use the [Pipecat CLI](https://github.com/pipecat-ai/pipecat-cli)
+  instead.
+
+## [0.2.6] - 2025-10-09
+
+### Added
+
+- Added an optional `--profile` option to the `deploy` command which selects between
+  `agent-1x`, with 0.5 vCPUs / 1 GB RAM, and `agent-2x`, with 1 vCPU / 2 GB RAM. The
+  default profile is `agent-1x`.
+
+### Fixed
+
+- Fixed an issue where the `agent status` CLI command would return incorrect
+  values for Min and Max Agents.
+
 ## [0.2.5] - 2025-10-02
 
 ### Added

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

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

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

@@ -66,6 +66,7 @@ class DeployConfigParams:
     enable_krisp: bool = False
     enable_managed_keys: bool = False
     docker_config: dict = field(factory=dict)
+    agent_profile: Optional[str] = None
 
     def __attrs_post_init__(self):
         if self.image is not None and ":" not in self.image:
@@ -81,6 +82,7 @@ class DeployConfigParams:
             "enable_krisp": self.enable_krisp,
             "enable_managed_keys": self.enable_managed_keys,
             "docker_config": self.docker_config,
+            "agent_profile": self.agent_profile,
         }
 
 
@@ -121,6 +123,7 @@ def load_deploy_config_file() -> Optional[DeployConfigParams]:
             "enable_krisp",
             "enable_managed_keys",
             "docker",
+            "agent_profile",
         }
         unexpected_keys = set(config_data.keys()) - expected_keys
         if unexpected_keys:

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

@@ -15,8 +15,8 @@ try:
     from pipecat.runner.types import (
         DailyRunnerArguments,
         RunnerArguments,
-        WebSocketRunnerArguments,
         SmallWebRTCRunnerArguments,
+        WebSocketRunnerArguments,
     )
 
     _PIPECAT_RUNNER_TYPES_AVAILABLE = True
@@ -33,9 +33,10 @@ except ImportError:
             will be removed in a future release.
         """
 
-        handle_sigint: bool = field(init=False)
-        handle_sigterm: bool = field(init=False)
-        pipeline_idle_timeout_secs: int = field(init=False)
+        handle_sigint: bool = field(init=False, kw_only=True)
+        handle_sigterm: bool = field(init=False, kw_only=True)
+        pipeline_idle_timeout_secs: int = field(init=False, kw_only=True)
+        body: Optional[Any] = field(default_factory=dict, kw_only=True)
 
         def __post_init__(self):
             self.handle_sigint = False
@@ -52,7 +53,6 @@ except ImportError:
 
         room_url: str
         token: str
-        body: Any
 
     @dataclass
     class WebSocketRunnerArguments(RunnerArguments):
@@ -63,7 +63,6 @@ except ImportError:
         """
 
         websocket: WebSocket
-        body: Any
 
     @dataclass
     class SmallWebRTCRunnerArguments(RunnerArguments):
@@ -112,7 +111,9 @@ class PipecatSessionArguments(RunnerArguments, SessionArguments):
     For best compatibility, install: pip install pipecatcloud[pipecat]
     """
 
-    body: Any
+    def __post_init__(self):
+        RunnerArguments.__post_init__(self)
+        _warn_standalone_usage()
 
 
 @dataclass
@@ -144,6 +145,7 @@ class WebSocketSessionArguments(WebSocketRunnerArguments, SessionArguments):
         WebSocketRunnerArguments.__post_init__(self)
         _warn_standalone_usage()
 
+
 @dataclass
 class SmallWebRTCSessionArguments(SmallWebRTCRunnerArguments, SessionArguments):
     """SmallWebRTCTransport based agent session arguments.

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

@@ -322,6 +322,7 @@ class _API:
             },
             "enableKrisp": deploy_config.enable_krisp,
             "enableIntegratedKeysProxy": deploy_config.enable_managed_keys,  # API expects this field name
+            "agentProfile": deploy_config.agent_profile,
         }
 
         # Remove None values recursively
@@ -437,3 +438,17 @@ class _API:
     @property
     def agent_sessions(self):
         return self.create_api_method(self._agent_sessions)
+
+    async def _agent_session_terminate(self, agent_name: str, session_id: str, org: str) -> dict | None:
+        url = f"{self.construct_api_url('services_sessions_path').format(org=org, service=agent_name)}/{session_id}"
+        return await self._base_request("DELETE", url, not_found_is_empty=True)
+
+    @property
+    def agent_session_terminate(self):
+        """Terminate an active session for an agent.
+        Args:
+            agent_name: Name of the agent
+            session_id: ID of the session to terminate
+            org: Organization ID
+        """
+        return self.create_api_method(self._agent_session_terminate)

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

@@ -21,11 +21,16 @@ from rich.text import Text
 
 from pipecatcloud._utils.async_utils import synchronizer
 from pipecatcloud._utils.auth_utils import requires_login
-from pipecatcloud._utils.console_utils import console, format_duration, format_timestamp, calculate_percentiles
+from pipecatcloud._utils.console_utils import (
+    calculate_percentiles,
+    console,
+    format_duration,
+    format_timestamp,
+)
+from pipecatcloud._utils.deploy_utils import DeployConfigParams, with_deploy_config
 from pipecatcloud.cli import PIPECAT_CLI_NAME
 from pipecatcloud.cli.api import API
 from pipecatcloud.cli.config import config
-from pipecatcloud._utils.deploy_utils import with_deploy_config, DeployConfigParams
 
 agent_cli = typer.Typer(name="agent", help="Agent management", no_args_is_help=True)
 
@@ -54,7 +59,8 @@ async def list(
         if not data or len(data) == 0:
             console.error(
                 f"[red]No agents found for namespace / organization '{org}'[/red]\n\n"
-                f"[dim]Please deploy an agent first using[/dim] [bold cyan]{PIPECAT_CLI_NAME} deploy[/bold cyan]")
+                f"[dim]Please deploy an agent first using[/dim] [bold cyan]{PIPECAT_CLI_NAME} deploy[/bold cyan]"
+            )
             return typer.Exit(1)
 
         else:
@@ -119,6 +125,15 @@ async def status(
             "[bold]Image:[/bold]",
             str(data.get("deployment", {}).get("manifest", {}).get("spec", {}).get("image", "N/A")),
         )
+
+        # Display agent profile if available
+        agent_profile = data.get("agentProfile")
+        if agent_profile:
+            deployment_table.add_row(
+                "[bold]Agent Profile:[/bold]",
+                str(agent_profile),
+            )
+
         deployment_table.add_row(
             "[bold]Active Deployment ID:[/bold]",
             str(data.get("activeDeploymentId", "N/A")),
@@ -131,10 +146,15 @@ 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", {})
+        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:
@@ -150,11 +170,11 @@ async def status(
         if autoscaling_data:
             scaling_renderables = [
                 Panel(
-                    f"[bold]Minimum Agents[/bold]\n{autoscaling_data.get('minAgents', 0)}",
+                    f"[bold]Minimum Agents[/bold]\n{autoscaling_data.get('minReplicas', 0)}",
                     expand=True,
                 ),
                 Panel(
-                    f"[bold]Maximum Agents[/bold]\n{autoscaling_data.get('maxAgents', 0)}",
+                    f"[bold]Maximum Agents[/bold]\n{autoscaling_data.get('maxReplicas', 0)}",
                     expand=True,
                 ),
             ]
@@ -217,9 +237,7 @@ async def status(
 async def sessions(
     deploy_config=typer.Option(None, hidden=True),
     agent_name: str = typer.Argument(
-        None,
-        help="Name of the agent to list sessions for e.g. 'my-agent'",
-        show_default=False
+        None, help="Name of the agent to list sessions for e.g. 'my-agent'", show_default=False
     ),
     session_id: str = typer.Option(
         None,
@@ -232,7 +250,7 @@ async def sessions(
     ),
 ):
     org = organization or config.get("org")
-    
+
     # Get agent name from argument or deploy config
     if not agent_name:
         if deploy_config and deploy_config.agent_name:
@@ -264,15 +282,17 @@ async def sessions(
         for session in completed_sessions:
             try:
                 from datetime import datetime
-                created_at = datetime.fromisoformat(session["createdAt"].replace('Z', '+00:00'))
-                ended_at = datetime.fromisoformat(session["endedAt"].replace('Z', '+00:00'))
+
+                created_at = datetime.fromisoformat(session["createdAt"].replace("Z", "+00:00"))
+                ended_at = datetime.fromisoformat(session["endedAt"].replace("Z", "+00:00"))
                 duration_seconds = (ended_at - created_at).total_seconds()
                 durations.append(duration_seconds)
             except BaseException:
                 continue
 
-        bot_start_times = [s["botStartSeconds"]
-                           for s in sessions_list if s.get("botStartSeconds") is not None]
+        bot_start_times = [
+            s["botStartSeconds"] for s in sessions_list if s.get("botStartSeconds") is not None
+        ]
         bot_start_metrics = calculate_percentiles(bot_start_times)
         duration_metrics = calculate_percentiles(durations)
         cold_starts_count = sum(1 for s in sessions_list if s.get("coldStart") is True)
@@ -317,8 +337,9 @@ async def sessions(
             if session_id and session["sessionId"] != session_id:
                 continue
 
-            session_duration = format_duration(
-                session["createdAt"], session["endedAt"]) or "[dim]N/A[/dim]"
+            session_duration = (
+                format_duration(session["createdAt"], session["endedAt"]) or "[dim]N/A[/dim]"
+            )
             status = session.get("completionStatus", "")
             if session["endedAt"]:
                 if status == "500":
@@ -333,14 +354,18 @@ async def sessions(
 
             row_data = [
                 session["sessionId"],
-                format_timestamp(
-                    session["createdAt"]),
-                format_timestamp(
-                    session["endedAt"]) if session["endedAt"] else "[dim]N/A[/dim]",
+                format_timestamp(session["createdAt"]),
+                format_timestamp(session["endedAt"]) if session["endedAt"] else "[dim]N/A[/dim]",
                 session_duration,
                 status_display,
-                f"{session['botStartSeconds']}s" if session["botStartSeconds"] is not None else "[dim]N/A[/dim]",
-                "[red]Yes[/red]" if session["coldStart"] is True else "No" if session["coldStart"] is False else "[dim]N/A[/dim]",
+                f"{session['botStartSeconds']}s"
+                if session["botStartSeconds"] is not None
+                else "[dim]N/A[/dim]",
+                "[red]Yes[/red]"
+                if session["coldStart"] is True
+                else "No"
+                if session["coldStart"] is False
+                else "[dim]N/A[/dim]",
             ]
 
             if is_cold_start:
@@ -350,10 +375,11 @@ async def sessions(
 
         console.success(
             Group(
-                Columns(
-                    metric_renderables,
-                    equal=True) if metric_renderables and not session_id else "",
-                table),
+                Columns(metric_renderables, equal=True)
+                if metric_renderables and not session_id
+                else "",
+                table,
+            ),
             title=f"Session data for agent {agent_name} [dim]({org})[/dim]",
         )
 
@@ -390,32 +416,16 @@ class LogLevelColors(str, Enum):
 @synchronizer.create_blocking
 @requires_login
 async def logs(
-        agent_name: str,
-        organization: str = typer.Option(
-            None,
-            "--organization",
-            "-o",
-            help="Organization to get status of agent for"),
-        level: LogLevel = typer.Option(
-            None,
-            "--level",
-            "-l",
-            help="Level of logs to get"),
-        format: LogFormat = typer.Option(
-            LogFormat.TEXT,
-            "--format",
-            "-f",
-            help="Logs format"),
-        limit: int = typer.Option(
-            100,
-            "--limit",
-            "-n",
-            help="Number of logs to get"),
-        deployment_id: str = typer.Option(
-            None,
-            "--deployment",
-            "-d",
-            help="Filter logs by deployment ID"),
+    agent_name: str,
+    organization: str = typer.Option(
+        None, "--organization", "-o", help="Organization to get status of agent for"
+    ),
+    level: LogLevel = typer.Option(None, "--level", "-l", help="Level of logs to get"),
+    format: LogFormat = typer.Option(LogFormat.TEXT, "--format", "-f", help="Logs format"),
+    limit: int = typer.Option(100, "--limit", "-n", help="Number of logs to get"),
+    deployment_id: str = typer.Option(
+        None, "--deployment", "-d", help="Filter logs by deployment ID"
+    ),
 ):
     org = organization or config.get("org")
 
@@ -425,7 +435,9 @@ async def logs(
         f"[dim]Fetching logs for {status_text}: [bold]'{agent_name}'[/bold] with severity: [bold cyan]{level.value if level else 'ALL'}[/bold cyan][/dim]",
         spinner="dots",
     ):
-        data, error = await API.agent_logs(agent_name=agent_name, org=org, limit=limit, deployment_id=deployment_id)
+        data, error = await API.agent_logs(
+            agent_name=agent_name, org=org, limit=limit, deployment_id=deployment_id
+        )
 
         if not data or not data.get("logs"):
             console.print("[dim]No logs found for agent[/dim]")
@@ -539,12 +551,13 @@ async def deployments(
             table.add_column("Updated At")
 
             for deployment in data["deployments"]:
+                spec = deployment.get("manifest", {}).get("spec", {})
                 table.add_row(
-                    deployment["id"],
-                    deployment["manifest"]["spec"]["dailyNodeType"],
-                    deployment["manifest"]["spec"]["image"],
-                    deployment["createdAt"],
-                    deployment["updatedAt"],
+                    deployment.get("id", "N/A"),
+                    spec.get("dailyNodeType", "N/A"),
+                    spec.get("image", "N/A"),
+                    deployment.get("createdAt", "N/A"),
+                    deployment.get("updatedAt", "N/A"),
                 )
 
             console.print(
@@ -636,7 +649,8 @@ async def start(
                 title="Public API Key Required",
                 title_align="left",
                 border_style="yellow",
-            ))
+            )
+        )
 
         return typer.Exit(1)
 
@@ -666,7 +680,8 @@ async def start(
                 title=f"[bold]Start Request for agent: {agent_name}[/bold]",
                 title_align="left",
                 border_style="yellow",
-            ))
+            )
+        )
         if not await questionary.confirm(
             "Are you sure you want to start an active session for this agent?"
         ).ask_async():
@@ -715,3 +730,70 @@ async def start(
                 url = f"{daily_room}?t={daily_token}"
                 console.print("\nJoin your session by visiting the link below:")
                 console.print(f"[link={url}]{url}[/link]")
+
+
+@agent_cli.command(name="stop", help="Stop an active agent session")
+@synchronizer.create_blocking
+@requires_login
+@with_deploy_config
+async def stop(
+    deploy_config=typer.Option(None, hidden=True),
+    agent_name: str = typer.Argument(None, help="Name of the agent e.g. 'my-agent'"),
+    session_id: str = typer.Option(
+        ...,
+        "--session-id",
+        "-s",
+        help="ID of the session to stop",
+    ),
+    organization: str = typer.Option(
+        None, "--organization", "-o", help="Organization which the agent belongs to"
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Bypass prompt for confirmation",
+    ),
+):
+    org = organization or config.get("org")
+
+    # Load values from deployment config file (if one exists)
+    partial_config = deploy_config or DeployConfigParams()
+
+    # Get agent name from argument or deploy config
+    if not agent_name:
+        if partial_config and partial_config.agent_name:
+            agent_name = partial_config.agent_name
+        else:
+            console.error("No target agent name provided")
+            return typer.Exit(1)
+
+    # Confirm stop request
+    if not force:
+        console.print(
+            Panel(
+                f"Agent Name: {agent_name}\n"
+                f"Session ID: {session_id}",
+                title=f"[bold]Stop Session[/bold]",
+                title_align="left",
+                border_style="yellow",
+            )
+        )
+        if not await questionary.confirm(
+            "Are you sure you want to stop this session?"
+        ).ask_async():
+            console.print("[bold]Aborting stop request[/bold]")
+            return typer.Exit(1)
+
+    with console.status(
+        f"[dim]Stopping session [bold]'{session_id}'[/bold] for agent [bold]'{agent_name}'[/bold][/dim]",
+        spinner="dots",
+    ):
+        data, error = await API.agent_session_terminate(
+            agent_name=agent_name, session_id=session_id, org=org
+        )
+
+        if error:
+            return typer.Exit(1)
+
+        console.success(f"Session '{session_id}' stopped successfully")

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

@@ -285,6 +285,13 @@ def create_deploy_command(app: typer.Typer):
             help="Enable Managed Keys for this deployment",
             rich_help_panel="Deployment Configuration",
         ),
+        profile: str = typer.Option(
+            None,
+            "--profile",
+            "-p",
+            help="Agent profile to use for deployment",
+            rich_help_panel="Deployment Configuration",
+        ),
         skip_confirm: bool = typer.Option(
             False,
             "--force",
@@ -352,6 +359,7 @@ def create_deploy_command(app: typer.Typer):
         )
         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
 
         # Assert agent name and image are provided
         if not partial_config.agent_name:
@@ -388,6 +396,7 @@ def create_deploy_command(app: typer.Typer):
             (f"[bold white]Organization:[/bold white] [green]{org}[/green]"),
             (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]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.2.5 → pipecatcloud-0.2.7}/src/pipecatcloud/cli/commands/init.py

@@ -5,6 +5,7 @@
 #
 
 import os
+import warnings
 import zipfile
 from typing import Set
 
@@ -40,9 +41,25 @@ def check_existing_files() -> Set[str]:
 
 
 def create_init_command(app: typer.Typer):
-    @app.command(name="init", help="Initialize project directory with template files")
+    @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():

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

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

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

@@ -45,5 +45,6 @@ src/pipecatcloud/cli/commands/secrets.py
 src/pipecatcloud/smallwebrtc/session_manager.py
 tests/__init__.py
 tests/test_agent_sessions.py
+tests/test_agent_stop.py
 tests/test_docker_commands.py
 tests/test_managed_keys.py

pipecatcloud-0.2.7/tests/test_agent_stop.py

@@ -0,0 +1,99 @@
+"""
+Unit tests for the 'pcc agent stop' command.
+
+Tests focus on core behaviors and edge cases, not implementation details.
+"""
+
+import pytest
+import typer
+from unittest.mock import patch, AsyncMock, MagicMock
+
+# Import the function under test from local source
+from src.pipecatcloud.cli.commands.agent import stop
+
+# Test constants
+TEST_ORG = "test-org"
+TEST_AGENT = "test-agent"
+TEST_SESSION_ID = "session-123"
+
+
+class TestAgentStopCommand:
+    """Test the 'pcc agent stop' command behaviors."""
+
+    def test_stop_respects_force_flag(self):
+        """Verify force flag skips confirmation when set to True."""
+        with patch('src.pipecatcloud.cli.commands.agent.console') as mock_console, \
+             patch('src.pipecatcloud.cli.commands.agent.config') as mock_config, \
+             patch('src.pipecatcloud.cli.commands.agent.questionary') as mock_questionary, \
+             patch('src.pipecatcloud.cli.commands.agent.DeployConfigParams') as mock_params:
+
+            mock_config.get.return_value = TEST_ORG
+            mock_params.return_value = MagicMock(agent_name=TEST_AGENT)
+            # Mock questionary - should NOT be called when force=True
+            mock_questionary.confirm.return_value.ask_async = AsyncMock()
+
+            # Act with force=True
+            stop(
+                deploy_config=None,
+                agent_name=TEST_AGENT,
+                session_id=TEST_SESSION_ID,
+                organization=TEST_ORG,
+                force=True,
+            )
+
+            # Assert
+            # questionary.confirm should not be called when force=True
+            mock_questionary.confirm.assert_not_called()
+
+    def test_stop_shows_confirmation_without_force(self):
+        """Verify confirmation prompt is shown when force is False."""
+        with patch('src.pipecatcloud.cli.commands.agent.console') as mock_console, \
+             patch('src.pipecatcloud.cli.commands.agent.config') as mock_config, \
+             patch('src.pipecatcloud.cli.commands.agent.questionary') as mock_questionary, \
+             patch('src.pipecatcloud.cli.commands.agent.DeployConfigParams') as mock_params:
+
+            mock_config.get.return_value = TEST_ORG
+            mock_params.return_value = MagicMock(agent_name=TEST_AGENT)
+            # User agrees to the confirmation
+            mock_questionary.confirm.return_value.ask_async = AsyncMock(return_value=True)
+
+            # Act with force=False
+            stop(
+                deploy_config=None,
+                agent_name=TEST_AGENT,
+                session_id=TEST_SESSION_ID,
+                organization=TEST_ORG,
+                force=False,
+            )
+
+            # Assert
+            # questionary.confirm should be called when force=False
+            mock_questionary.confirm.assert_called_once()
+
+    def test_stop_aborts_on_user_rejection(self):
+        """Verify command aborts when user rejects the confirmation."""
+        with patch('src.pipecatcloud.cli.commands.agent.console') as mock_console, \
+             patch('src.pipecatcloud.cli.commands.agent.config') as mock_config, \
+             patch('src.pipecatcloud.cli.commands.agent.questionary') as mock_questionary, \
+             patch('src.pipecatcloud.cli.commands.agent.DeployConfigParams') as mock_params:
+
+            mock_config.get.return_value = TEST_ORG
+            mock_params.return_value = MagicMock(agent_name=TEST_AGENT)
+            # User rejects the confirmation
+            mock_questionary.confirm.return_value.ask_async = AsyncMock(return_value=False)
+
+            # Act
+            result = stop(
+                deploy_config=None,
+                agent_name=TEST_AGENT,
+                session_id=TEST_SESSION_ID,
+                organization=TEST_ORG,
+                force=False,
+            )
+
+            # Assert
+            # Should exit with code 1 (abort)
+            assert isinstance(result, typer.Exit)
+            assert result.exit_code == 1
+            # Should display abort message
+            mock_console.print.assert_any_call("[bold]Aborting stop request[/bold]")

{pipecatcloud-0.2.5 → pipecatcloud-0.2.7}/tests/test_managed_keys.py

@@ -5,17 +5,12 @@ Tests follow AAA pattern and focus on behaviors/outcomes rather than implementat
 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
+from unittest.mock import AsyncMock, 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:
@@ -25,7 +20,7 @@ class TestDeployConfigDataModel:
         """When not specified, managed keys should default to disabled."""
         # Arrange & Act
         config = DeployConfigParams()
-        
+
         # Assert
         assert config.enable_managed_keys is False
 
@@ -33,21 +28,18 @@ class TestDeployConfigDataModel:
         """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
-        )
-        
+        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
@@ -59,12 +51,12 @@ class TestDeployConfigDataModel:
             agent_name="test-agent",
             image="test:latest",
             enable_krisp=True,
-            enable_managed_keys=True
+            enable_managed_keys=True,
         )
-        
+
         # Act
         result = config.to_dict()
-        
+
         # Assert
         assert result["agent_name"] == "test-agent"
         assert result["image"] == "test:latest"
@@ -90,11 +82,11 @@ class TestTOMLConfiguration:
         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
@@ -108,11 +100,11 @@ class TestTOMLConfiguration:
         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
@@ -125,11 +117,11 @@ class TestTOMLConfiguration:
         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
@@ -149,11 +141,11 @@ class TestTOMLConfiguration:
         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"
@@ -164,7 +156,6 @@ class TestTOMLConfiguration:
         assert config.scaling.max_agents == 10
 
 
-
 class TestAPIIntegration:
     """Test API client integration with managed keys."""
 
@@ -178,17 +169,15 @@ class TestAPIIntegration:
         """Deploy payload should include enableIntegratedKeys field."""
         # Arrange
         config = DeployConfigParams(
-            agent_name="test-agent",
-            image="test:latest",
-            enable_managed_keys=True
+            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"]
@@ -200,17 +189,15 @@ class TestAPIIntegration:
         """Update payload should include enableIntegratedKeys field."""
         # Arrange
         config = DeployConfigParams(
-            agent_name="test-agent",
-            image="test:latest",
-            enable_managed_keys=True
+            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"]
@@ -222,17 +209,15 @@ class TestAPIIntegration:
         """When managed keys is disabled, API should send false value."""
         # Arrange
         config = DeployConfigParams(
-            agent_name="test-agent",
-            image="test:latest",
-            enable_managed_keys=False
+            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"]
@@ -253,24 +238,26 @@ class TestAgentStatusDisplay:
         """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))
-        
+
+        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
@@ -280,20 +267,24 @@ class TestAgentStatusDisplay:
         """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))
-        
+
+        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
@@ -303,22 +294,24 @@ class TestAgentStatusDisplay:
         """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))
-        
+
+        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
@@ -331,15 +324,11 @@ class TestBackwardCompatibility:
     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
-        )
-        
+        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
@@ -347,24 +336,20 @@ class TestBackwardCompatibility:
     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"
-                    }
-                }
-            }
-        }
-        
+        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", {})
+        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
 
@@ -389,7 +374,7 @@ class TestBackwardCompatibility:
         # 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"
@@ -407,14 +392,12 @@ class TestErrorHandling:
         # Arrange
         api = _API(token="test-token", is_cli=True)
         config = DeployConfigParams(
-            agent_name="test-agent",
-            image="test:latest",
-            enable_managed_keys=True
+            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)
@@ -426,12 +409,12 @@ class TestErrorHandling:
             agent_name="test-agent",
             image="test:latest",
             enable_krisp=True,
-            enable_managed_keys=True
+            enable_managed_keys=True,
         )
-        
+
         # Act
         result = config.to_dict()
-        
+
         # Assert
         assert result["enable_krisp"] is True
-        assert result["enable_managed_keys"] is True
+        assert result["enable_managed_keys"] is True