pipecatcloud 0.5.0__tar.gz → 0.7.0__tar.gz

pipecatcloud-0.7.0/.claude/settings.json

@@ -0,0 +1,5 @@
+{
+  "attribution": {
+    "commit": ""
+  }
+}

pipecatcloud-0.7.0/.pre-commit-config.yaml

@@ -0,0 +1,13 @@
+repos:
+  - repo: local
+    hooks:
+      - id: ruff
+        name: ruff
+        entry: uv run ruff check --fix
+        language: system
+        types: [python]
+      - id: ruff-format
+        name: ruff-format
+        entry: uv run ruff format
+        language: system
+        types: [python]

{pipecatcloud-0.5.0 → pipecatcloud-0.7.0}/CHANGELOG.md

@@ -5,6 +5,53 @@ 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.7.0] - 2026-05-07
+
+### Added
+
+- `pcc secrets list` now shows a `Status` column for each secret set
+  (`ready`, `pending`, or `failed`). When a single set is requested
+  (`pcc secrets list <name>`), the readiness status is shown in the panel
+  title alongside the keys, and a follow-up message explains pending or
+  failed states. Backed by a new `secrets_get` API client method that
+  fetches a single secret set's full payload, including readiness fields.
+
+### Changed
+
+- `pcc agent status` and the `pcc deploy` polling output now show
+  customer-friendly headlines for failed deployments when the API
+  supplies them. An OOM-killed container reads "Out of memory" instead
+  of "CrashLoopBackOff (OOMKilled, exit 137)"; an application crash
+  reads "Application Error" with the captured traceback on the next
+  line. Exit codes render as "exit code N" rather than "exit N" for
+  clarity. Older API responses without the new field continue to render
+  via the previous format.
+
+## [0.6.0] - 2026-04-22
+
+### Added
+
+- `websocket_auth` config option in `pcc-deploy.toml` to control authentication
+  mode for the generic WebSocket handler (`/ws/generic`). Valid values are
+  `"none"` (no authentication required) and `"token"` (requires a session token
+  obtained via `/start`). New services default to `"token"` if not specified.
+
+- `--max-session-duration` flag on `pcc deploy` for configuring the
+  per-service maximum session duration in seconds. Accepts values
+  between 60 and 14400 (4 hours), defaulting to 7200 (2 hours) when
+  unset. Also exposed in `pcc agent status` output and as
+  `max_session_duration` in `pcc-deploy.toml`.
+
+### Fixed
+
+- `.dockerignore` patterns written with Docker's conventional trailing
+  slash (e.g. `.venv/`, `node_modules/`) and leading `./` anchors
+  (e.g. `./dist`) now match correctly in cloud builds. Previously the
+  CLI compared patterns with `fnmatch`, which treats both forms as
+  literal text, so these entries silently excluded nothing and large
+  directories like `.venv/` could leak into the build context and
+  trip the 500 MB limit.
+
 ## [0.5.0] - 2026-04-17
 
 ### Changed

pipecatcloud-0.7.0/CLAUDE.md

@@ -0,0 +1,119 @@
+# CLAUDE.md
+
+Guidance for Claude Code working in this repo.
+
+## What this is
+
+**Pipecat Cloud** is the Python SDK and `pcc` CLI for deploying and managing Pipecat voice agents on Pipecat Cloud infrastructure. It ships to PyPI as `pipecatcloud`. Users install it to authenticate, build and push container images, deploy agents, manage secrets and scaling, and open sessions against running agents.
+
+- Package root: `src/pipecatcloud/`
+- CLI entry points: `pcc` and `pipecatcloud` (also registered as a Pipecat CLI extension via the `pipecat_cli.extensions:cloud` entry point)
+- Public docs: https://docs.pipecat.daily.co
+
+## Toolchain
+
+- **Python 3.11+** (bumped from 3.10 in v0.5.0 to match Pipecat 1.0). Type hints use `X | Y` syntax, not `Union[X, Y]`.
+- **uv** for dependency management. `uv.lock` is committed.
+- **setuptools** build backend. Version is derived from git tags via `setuptools_scm` (tag format `v0.6.0`), so there is no hand-edited version file.
+- **Ruff** for lint and format (100-char line length, `I` and `UP` rule sets).
+- **Pyright** for type checking.
+- **Pytest** with `pytest-asyncio` in `auto` mode.
+
+## Common commands
+
+Always use `uv run` rather than activating a venv.
+
+```bash
+# First-time setup
+uv sync --group dev
+uv run pre-commit install
+
+# Tests
+uv run pytest                                    # full suite
+uv run pytest tests/test_auth.py                 # single file
+uv run pytest tests/test_auth.py::TestPKCE       # single class
+uv run pytest -v                                 # verbose
+
+# Lint / format / typecheck
+uv run ruff format .
+uv run ruff check --fix .
+uv run pyright
+bash scripts/fix-ruff.sh                         # format + check --fix
+
+# Build (usually CI-only)
+uv build
+```
+
+Pre-commit runs `ruff format` and `ruff check --fix` on every commit. If the hook fails, fix the issue and make a **new** commit rather than amending.
+
+## Repository layout
+
+```
+src/pipecatcloud/
+  __init__.py            Public SDK surface (Session, exceptions, session argument types)
+  api.py                 Async aiohttp API client (_API class)
+  session.py             User-facing Session client
+  agent.py               Session argument types with fallbacks when pipecat-ai is absent
+  config.py              Base settings, API path constants
+  constants.py           Krisp VIVA models, region-related literals
+  exception.py           Error hierarchy (AuthError, AgentStartError, etc.)
+  cli/
+    entry_point.py       Typer app, wired as a Pipecat CLI extension
+    config.py            Reads/writes ~/.config/pipecatcloud/pipecatcloud.toml
+    api.py               CLI-flavored wrapper around _API
+    commands/            auth, agent, deploy, docker, build, secrets, regions, organizations
+  _utils/
+    auth_utils.py        @requires_login decorator, default-org resolution
+    build_utils.py       Deterministic tarballs, S3 upload, build polling
+    deploy_utils.py      pcc-deploy.toml parsing, deployment-status interpretation
+    regions.py           Region fetch and validation
+    async_utils.py       synchronizer for bridging async into the sync Typer CLI
+    console_utils.py     Rich console helpers
+  smallwebrtc/
+    session_manager.py   SmallWebRTC support for non-Pipecat agents
+tests/                   Pytest suite, parallel to src/
+.github/workflows/       tests.yml, format.yml, publish-pypi.yml, publish-test.yml
+pcc-deploy.toml          Example deployment config consumed by `pcc deploy`
+```
+
+## Testing conventions
+
+- Layout mirrors `src/`. New tests go in `tests/test_<module>.py`.
+- `tests/conftest.py` sets `PIPECAT_CONFIG_PATH` to an isolated temp file **before imports**, pre-populated with `token = "test-token"` and `org = "test-org"`. This prevents tests from reading or clobbering real credentials. Do not bypass it.
+- Async tests use `@pytest.mark.asyncio`. Mock async calls with `unittest.mock.AsyncMock`.
+- `tests/test_agent_sessions.py` is **skipped in CI** because it needs real auth or heavier mocking. Run it locally if you touch session code.
+- `pytest.ini` uses `--import-mode=importlib`. Some tests manually insert `src/` onto `sys.path`, which is expected.
+
+## CI
+
+- `tests.yml` runs on push to main and PRs. It currently runs `uv run pytest tests/test_docker_commands.py -v` rather than the full suite, so green CI does not guarantee the whole suite passes. Run `uv run pytest` locally before opening PRs.
+- `format.yml` runs `ruff format --diff` and `ruff check`. Both must pass.
+- `publish-pypi.yml` and `publish-test.yml` are manual dispatches that build and publish a specific git tag.
+
+## Config and environment
+
+- User config lives at `~/.config/pipecatcloud/pipecatcloud.toml`. Overridable with `PIPECAT_CONFIG_PATH`.
+- Deployment config is `pcc-deploy.toml` in the project root. Overridable with `PIPECAT_DEPLOY_CONFIG_PATH`.
+- Other overrides follow the `PIPECAT_<UPPERCASE_SETTING>` pattern (e.g. `PIPECAT_API_HOST`).
+- `PCC_LOG_LEVEL` controls the loguru log level (default `INFO`). This codebase uses **loguru**, not the stdlib `logging` module.
+- The credentials file is force-chmod'd to `0600` on read and written atomically (temp file, fsync, rename). Preserve this when touching `cli/config.py`.
+
+## Gotchas
+
+- The CLI is sync (Typer) but the API client is async. Bridge with `@synchronizer` from `_utils/async_utils.py`. Do not invent a new bridging pattern.
+- Auth uses OAuth2 with PKCE (RFC 7636). OAuth endpoints are discovered from the API server, not hardcoded. The callback server tries ports 8400-8404.
+- `SmallWebRTCSessionArguments` and `SmallWebRTCRunnerArguments` have fallback definitions in `agent.py` for when `pipecat-ai` isn't installed. Keep the two paths in sync.
+- Krisp VIVA audio filter names are `Literal["tel", "pro"]` in `constants.py`. These must match the server-side ConfigMap, so coordinate changes with the backend.
+
+## Release flow
+
+1. Update `CHANGELOG.md` following Keep a Changelog format.
+2. Tag the commit with `v<MAJOR>.<MINOR>.<PATCH>`.
+3. Trigger `publish-pypi.yml` manually with that tag. `setuptools_scm` picks up the version from the tag.
+
+## Writing style for generated content in this repo
+
+- No emdashes.
+- Clear mid-length sentences. Short paragraphs.
+- Bold for key terms on first use only.
+- Don't hedge, don't hype, don't pad with "let's dive in" style openers.

{pipecatcloud-0.5.0 → pipecatcloud-0.7.0}/PKG-INFO

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

{pipecatcloud-0.5.0 → pipecatcloud-0.7.0}/pyproject.toml

@@ -56,9 +56,21 @@ include = ["pipecatcloud*"]
 pipecatcloud = ["py.typed"]
 
 [tool.ruff]
-exclude = ["*_pb2.py"]
 line-length = 100
 
+[tool.ruff.lint]
+select = [
+    "I", # Import rules
+    "UP", # Modern Python
+]
+
+[tool.ruff.lint.per-file-ignores]
+# Skip docstring checks for non-source code
+"tests/**/*.py" = ["D"]
+"scripts/**/*.py" = ["D"]
+# Skip D104 (missing docstring in public package) for __init__.py files
+"**/__init__.py" = ["D104"]
+
 [project.urls]
 Website = "https://docs.pipecat.daily.co/"
 

{pipecatcloud-0.5.0 → pipecatcloud-0.7.0}/src/pipecatcloud/_utils/auth_utils.py

@@ -5,7 +5,6 @@
 #
 
 import functools
-from typing import Optional
 
 import aiohttp
 
@@ -15,7 +14,7 @@ from pipecatcloud.cli import PIPECAT_CLI_NAME
 from pipecatcloud.cli.config import config
 
 
-async def _resolve_default_org(token: str) -> Optional[str]:
+async def _resolve_default_org(token: str) -> str | None:
     """Fetch the user's default organization using the given token."""
     from pipecatcloud.config import config as base_config
 

{pipecatcloud-0.5.0 → pipecatcloud-0.7.0}/src/pipecatcloud/_utils/build_utils.py

@@ -19,15 +19,15 @@ import io
 import os
 import tarfile
 import time
+from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Callable, List, Optional, Set, Tuple
 
 import aiohttp
 from loguru import logger
 
 # Default patterns to exclude from build context
-DEFAULT_EXCLUSIONS: Set[str] = {
+DEFAULT_EXCLUSIONS: set[str] = {
     # Version control
     ".git",
     ".gitignore",
@@ -116,7 +116,7 @@ class BuildStatus:
         return status in cls.TERMINAL_STATUSES
 
 
-def _should_exclude(path: Path, exclusions: Set[str], base_path: Path) -> bool:
+def _should_exclude(path: Path, exclusions: set[str], base_path: Path) -> bool:
     """
     Check if a path should be excluded from the build context.
 
@@ -143,7 +143,27 @@ def _should_exclude(path: Path, exclusions: Set[str], base_path: Path) -> bool:
     return False
 
 
-def load_dockerignore(context_dir: Path) -> Optional[Set[str]]:
+def _normalize_pattern(pattern: str) -> str:
+    """Normalize a single ``.dockerignore`` pattern for ``fnmatch`` matching.
+
+    The matcher in ``_should_exclude`` walks the tree and compares each
+    path component against every pattern with ``fnmatch.fnmatch``, which
+    treats the pattern as literal text. ``.dockerignore`` (and the
+    companion ``.gitignore`` grammar users pattern after) allows a few
+    pieces of sugar that ``fnmatch`` does not understand: a trailing
+    slash meaning "directory only", and a leading ``./`` anchoring to
+    the context root. Both forms are common in the wild and routinely
+    silently match nothing under a raw ``fnmatch`` implementation, so
+    we strip them here to make the pattern intent actually take effect.
+    """
+    normalized = pattern.strip()
+    if normalized.startswith("./"):
+        normalized = normalized[2:]
+    normalized = normalized.rstrip("/")
+    return normalized
+
+
+def load_dockerignore(context_dir: Path) -> set[str] | None:
     """
     Load patterns from .dockerignore file if it exists.
 
@@ -159,12 +179,15 @@ def load_dockerignore(context_dir: Path) -> Optional[Set[str]]:
 
     patterns = set()
     try:
-        with open(dockerignore_path, "r") as f:
+        with open(dockerignore_path) as f:
             for line in f:
-                line = line.strip()
+                stripped = line.strip()
                 # Skip comments and empty lines
-                if line and not line.startswith("#"):
-                    patterns.add(line)
+                if not stripped or stripped.startswith("#"):
+                    continue
+                normalized = _normalize_pattern(stripped)
+                if normalized:
+                    patterns.add(normalized)
     except Exception as e:
         logger.warning(f"Failed to read .dockerignore: {e}")
         return None
@@ -172,7 +195,7 @@ def load_dockerignore(context_dir: Path) -> Optional[Set[str]]:
     return patterns
 
 
-def get_exclusions(context_dir: Path, extra_patterns: Optional[List[str]] = None) -> Set[str]:
+def get_exclusions(context_dir: Path, extra_patterns: list[str] | None = None) -> set[str]:
     """
     Get the set of exclusion patterns to use.
 
@@ -195,13 +218,16 @@ def get_exclusions(context_dir: Path, extra_patterns: Optional[List[str]] = None
     # Use defaults + extras
     exclusions = DEFAULT_EXCLUSIONS.copy()
     if extra_patterns:
-        exclusions.update(extra_patterns)
+        for extra in extra_patterns:
+            normalized = _normalize_pattern(extra)
+            if normalized:
+                exclusions.add(normalized)
     return exclusions
 
 
 def create_deterministic_tarball(
     context_dir: str,
-    exclusions: Set[str],
+    exclusions: set[str],
     dockerfile_path: str = "Dockerfile",
 ) -> BuildContext:
     """
@@ -235,7 +261,7 @@ def create_deterministic_tarball(
         raise FileNotFoundError(f"Dockerfile not found: {dockerfile_full}")
 
     # Collect all files, sorted alphabetically
-    files_to_add: List[Tuple[Path, str]] = []
+    files_to_add: list[tuple[Path, str]] = []
 
     for root, dirs, files in os.walk(base_path):
         root_path = Path(root)
@@ -363,8 +389,8 @@ async def poll_build_status(
     api_client,
     poll_interval: float = 3.0,
     max_duration: float = 600.0,  # 10 minutes
-    status_callback: Optional[Callable[[dict], None]] = None,
-) -> Tuple[bool, dict]:
+    status_callback: Callable[[dict], None] | None = None,
+) -> tuple[bool, dict]:
     """
     Poll build status until completion or timeout.
 

{pipecatcloud-0.5.0 → pipecatcloud-0.7.0}/src/pipecatcloud/_utils/console_utils.py

@@ -6,7 +6,6 @@
 
 import statistics
 from datetime import datetime
-from typing import Optional, Union
 
 from rich.console import Console
 from rich.panel import Panel
@@ -18,9 +17,9 @@ class PipecatConsole(Console):
     def success(
         self,
         message,
-        title: Optional[str] = None,
-        title_extra: Optional[str] = None,
-        subtitle: Optional[str] = None,
+        title: str | None = None,
+        title_extra: str | None = None,
+        subtitle: str | None = None,
     ):
         if not title:
             title = f"{PANEL_TITLE_SUCCESS}{f' - {title_extra}' if title_extra is not None else ''}"
@@ -39,9 +38,9 @@ class PipecatConsole(Console):
     def error(
         self,
         message,
-        title: Optional[str] = None,
-        title_extra: Optional[str] = None,
-        subtitle: Optional[str] = None,
+        title: str | None = None,
+        title_extra: str | None = None,
+        subtitle: str | None = None,
     ):
         if not title:
             title = f"{PANEL_TITLE_ERROR}{f' - {title_extra}' if title_extra is not None else ''}"
@@ -74,8 +73,8 @@ class PipecatConsole(Console):
 
     def api_error(
         self,
-        error_code: Optional[Union[str, dict]] = None,
-        title: Optional[str] = "API Error",
+        error_code: str | dict | None = None,
+        title: str | None = "API Error",
         hide_subtitle: bool = False,
     ):
         DEFAULT_ERROR_MESSAGE = "Unknown error. Please contact support."

{pipecatcloud-0.5.0 → pipecatcloud-0.7.0}/src/pipecatcloud/_utils/deploy_utils.py

@@ -6,10 +6,9 @@
 
 import functools
 import os
-from datetime import datetime, timezone
+from collections.abc import Callable
+from datetime import UTC, datetime
 from enum import Enum
-from typing import Callable, List, Optional
-
 
 import toml
 import typer
@@ -42,12 +41,12 @@ class DeploymentStatus:
     status_message: str
     is_available: bool = False
     is_ready: bool = False
-    degraded_reason: Optional[str] = None
-    current_revision: Optional[dict] = None
-    previous_revision: Optional[dict] = None
+    degraded_reason: str | None = None
+    current_revision: dict | None = None
+    previous_revision: dict | None = None
 
 
-def _find_condition(conditions: list, condition_type: str) -> Optional[dict]:
+def _find_condition(conditions: list, condition_type: str) -> dict | None:
     """Find a condition by type from the conditions array."""
     for c in conditions:
         if c.get("type") == condition_type:
@@ -55,13 +54,13 @@ def _find_condition(conditions: list, condition_type: str) -> Optional[dict]:
     return None
 
 
-def _format_elapsed(phase_started_at: Optional[str]) -> str:
+def _format_elapsed(phase_started_at: str | None) -> str:
     """Format elapsed time since phaseStartedAt as a human-readable string."""
     if not phase_started_at:
         return ""
     try:
         started = datetime.fromisoformat(phase_started_at.replace("Z", "+00:00"))
-        elapsed = datetime.now(timezone.utc) - started
+        elapsed = datetime.now(UTC) - started
         total_seconds = int(elapsed.total_seconds())
         if total_seconds < 0:
             return ""
@@ -105,19 +104,26 @@ def format_health_lines(health: dict) -> list:
     """Format health details as indented lines under a revision."""
     lines = []
     reason_parts = []
+
+    # Prefer the customer-friendly headline from the API when present. Older API
+    # responses don't include it, so fall back to constructing a string from raw
+    # k8s fields.
+    headline = health.get("headline")
     reason = health.get("reason", "")
     term_reason = health.get("lastTerminationReason", "")
     exit_code = health.get("lastExitCode")
 
-    if reason:
+    if headline:
+        reason_parts.append(f"[red]{headline}[/red]")
+    elif reason:
         detail = reason
         if term_reason and term_reason != reason:
             detail += f" ({term_reason}"
             if exit_code is not None:
-                detail += f", exit {exit_code}"
+                detail += f", exit code {exit_code}"
             detail += ")"
         elif exit_code is not None:
-            detail += f" (exit {exit_code})"
+            detail += f" (exit code {exit_code})"
         reason_parts.append(f"[red]{detail}[/red]")
 
     restarts = health.get("restartCount", 0)
@@ -125,6 +131,11 @@ def format_health_lines(health: dict) -> list:
     if restarts > 0:
         reason_parts.append(f"[dim]·[/dim] {restarts} restarts across {replicas_started} replicas")
 
+    # When using the headline, surface the exit code as its own subhead segment.
+    # The fallback path already includes the exit code inline with the reason.
+    if headline and exit_code is not None:
+        reason_parts.append(f"[dim]·[/dim] exit code {exit_code}")
+
     if reason_parts:
         lines.append("      " + " ".join(reason_parts))
 
@@ -149,7 +160,7 @@ def _build_status_message(headline: str, current_rev=None, previous_rev=None) ->
 
 def interpret_deployment_status(
     agent_status: dict,
-    desired_deployment_id: Optional[str] = None,
+    desired_deployment_id: str | None = None,
 ) -> DeploymentStatus:
     """Interpret the raw API response into a structured deployment status.
 
@@ -253,12 +264,12 @@ def interpret_deployment_status(
 
 @dataclass
 class ScalingParams:
-    min_agents: Optional[int] = 0
-    max_agents: Optional[int] = None
+    min_agents: int | None = 0
+    max_agents: int | None = None
     # @deprecated
-    min_instances: Optional[int] = field(default=None, metadata={"deprecated": True})
+    min_instances: int | None = field(default=None, metadata={"deprecated": True})
     # @deprecated
-    max_instances: Optional[int] = field(default=None, metadata={"deprecated": True})
+    max_instances: int | None = field(default=None, metadata={"deprecated": True})
 
     def __attrs_post_init__(self):
         # Handle deprecated fields
@@ -288,7 +299,7 @@ class ScalingParams:
 
 @dataclass
 class KrispVivaConfig:
-    audio_filter: Optional[KrispVivaAudioFilter] = None
+    audio_filter: KrispVivaAudioFilter | None = None
 
     def __attrs_post_init__(self):
         # Validation against known models
@@ -309,7 +320,7 @@ class BuildConfig:
 
     context_dir: str = "."
     dockerfile: str = "Dockerfile"
-    exclude_patterns: List[str] = field(factory=list)
+    exclude_patterns: list[str] = field(factory=list)
 
     def to_dict(self):
         return {
@@ -321,19 +332,21 @@ class BuildConfig:
 
 @dataclass
 class DeployConfigParams:
-    agent_name: Optional[str] = None
-    image: Optional[str] = None
-    build_id: Optional[str] = None  # For cloud builds
-    image_credentials: Optional[str] = None
-    secret_set: Optional[str] = None
-    region: Optional[str] = None
+    agent_name: str | None = None
+    image: str | None = None
+    build_id: str | None = None  # For cloud builds
+    image_credentials: str | None = None
+    secret_set: str | None = None
+    region: str | None = None
     scaling: ScalingParams = ScalingParams()
     enable_krisp: bool = False
     docker_config: dict = field(factory=dict)
     build_config: BuildConfig = field(factory=BuildConfig)  # Cloud build configuration
-    agent_profile: Optional[str] = None
+    agent_profile: str | None = None
     krisp_viva: KrispVivaConfig = field(factory=KrispVivaConfig)
     force_redeploy: bool = False
+    websocket_auth: str | None = None
+    max_session_duration: int | None = None
 
     def __attrs_post_init__(self):
         if self.image is not None and ":" not in self.image:
@@ -341,6 +354,8 @@ class DeployConfigParams:
         # Cannot specify both image and build_id
         if self.image is not None and self.build_id is not None:
             raise ValueError("Cannot specify both 'image' and 'build_id'")
+        if self.max_session_duration is not None and not 60 <= self.max_session_duration <= 14400:
+            raise ValueError("max_session_duration must be between 60 and 14400 seconds")
 
     def to_dict(self):
         return {
@@ -356,17 +371,19 @@ class DeployConfigParams:
             "build_config": self.build_config.to_dict() if self.build_config else None,
             "agent_profile": self.agent_profile,
             "krisp_viva": self.krisp_viva.to_dict() if self.krisp_viva else None,
+            "websocket_auth": self.websocket_auth,
+            "max_session_duration": self.max_session_duration,
         }
 
 
-def load_deploy_config_file() -> Optional[DeployConfigParams]:
+def load_deploy_config_file() -> DeployConfigParams | None:
     from pipecatcloud.cli.config import deploy_config_path
 
     logger.debug(f"Deploy config path: {deploy_config_path}")
     logger.debug(f"Deploy config path exists: {os.path.exists(deploy_config_path)}")
 
     try:
-        with open(deploy_config_path, "r") as f:
+        with open(deploy_config_path) as f:
             config_data = toml.load(f)
     except Exception:
         return None
@@ -415,6 +432,8 @@ def load_deploy_config_file() -> Optional[DeployConfigParams]:
             "build",
             "agent_profile",
             "krisp_viva",
+            "websocket_auth",
+            "max_session_duration",
         }
         unexpected_keys = set(config_data.keys()) - expected_keys
         if unexpected_keys:
@@ -427,7 +446,7 @@ def load_deploy_config_file() -> Optional[DeployConfigParams]:
         raise ConfigFileError(str(e))
 
 
-CONFIG_FILE_OPTION: Optional[str] = typer.Option(
+CONFIG_FILE_OPTION: str | None = typer.Option(
     None,
     "--config-file",
     help=f"Path to deploy config file (default: {PIPECAT_DEPLOY_CONFIG_PATH})",
@@ -459,8 +478,10 @@ def with_deploy_config(func: Callable) -> Callable:
             deploy_config = load_deploy_config_file()
             kwargs["deploy_config"] = deploy_config
         except Exception as e:
-            logger.error(f"Error loading deploy config: {e}")
-            raise ConfigFileError(str(e))
+            from pipecatcloud._utils.console_utils import console
+
+            console.error(f"Error loading deploy config: {e}")
+            raise typer.Exit(1)
         return func(*args, **kwargs)
 
     return wrapper

{pipecatcloud-0.5.0 → pipecatcloud-0.7.0}/src/pipecatcloud/_utils/regions.py

@@ -10,16 +10,14 @@ Region utilities for Pipecat Cloud CLI.
 Provides functions to fetch and cache available regions from the API.
 """
 
-from typing import Dict, List, Optional
-
 from pipecatcloud.cli.api import API
 from pipecatcloud.cli.config import config
 
 # Module-level cache for regions
-_regions_cache: Optional[List[Dict[str, str]]] = None
+_regions_cache: list[dict[str, str]] | None = None
 
 
-async def get_regions() -> List[Dict[str, str]]:
+async def get_regions() -> list[dict[str, str]]:
     """
     Fetch available regions from the API with caching.
 
@@ -45,7 +43,7 @@ async def get_regions() -> List[Dict[str, str]]:
     return _regions_cache
 
 
-async def get_region_codes() -> List[str]:
+async def get_region_codes() -> list[str]:
     """
     Get list of region codes only.