pipecatcloud 0.0.9__tar.gz → 0.0.10__tar.gz

{pipecatcloud-0.0.9 → pipecatcloud-0.0.10}/CHANGELOG.md

@@ -5,6 +5,21 @@ 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.0.10] - 2025-03-04
+
+### Added
+- `init` convenience command will now populate the working directory with files from the starter project
+- `agent log` allows for optional severity level filtering
+
+### Changed
+- `agent status` and `deploy` no longer show superfluous data
+- `session.py` now correctly handles errors when starting agents
+- `secrets set` no longer prompts twice for confirmation if the secret set does not exist
+
+### Removed
+- `errors.py` removed as redundant (error message and code returned via API)
+- `agent_utils.py` removed as redundant (error message and code returned via API)
+
 ## [0.0.9] - 2025-02-27
 
 ### Added

{pipecatcloud-0.0.9 → pipecatcloud-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pipecatcloud
-Version: 0.0.9
+Version: 0.0.10
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.daily.co/
@@ -70,16 +70,26 @@ pcc auth login
 
 ### Usage in Python scripts
 
-If want to programmatically start an agent within a Python script, you can use the `pipecatcloud.agent` module.
+If want to programmatically start an agent within a Python script, you can use the `pipecatcloud.session` module.
 
 ```python
-from pipecatcloud.agent import Agent
-
-agent = Agent(
-    agent_name="your-agent-name",
-    organization="your-organization",
-    api_key="your-api-key",
-)
-
-await agent.start()
+from pipecatcloud.session import Session
+from pipecatcloud.exception import AgentStartError
+import asyncio
+
+async def main():
+    session = Session(
+        agent_name="your-agent-name",
+        api_key="pk_...",
+    )
+
+    try:
+        await session.start()
+    except AgentStartError as e:
+        print(e)
+    except Exception as e:
+        raise (e)
+
+if __name__ == "__main__":
+    asyncio.run(main())
 ```

{pipecatcloud-0.0.9 → pipecatcloud-0.0.10}/README.md

@@ -50,16 +50,26 @@ pcc auth login
 
 ### Usage in Python scripts
 
-If want to programmatically start an agent within a Python script, you can use the `pipecatcloud.agent` module.
+If want to programmatically start an agent within a Python script, you can use the `pipecatcloud.session` module.
 
 ```python
-from pipecatcloud.agent import Agent
-
-agent = Agent(
-    agent_name="your-agent-name",
-    organization="your-organization",
-    api_key="your-api-key",
-)
-
-await agent.start()
+from pipecatcloud.session import Session
+from pipecatcloud.exception import AgentStartError
+import asyncio
+
+async def main():
+    session = Session(
+        agent_name="your-agent-name",
+        api_key="pk_...",
+    )
+
+    try:
+        await session.start()
+    except AgentStartError as e:
+        print(e)
+    except Exception as e:
+        raise (e)
+
+if __name__ == "__main__":
+    asyncio.run(main())
 ```

{pipecatcloud-0.0.9 → pipecatcloud-0.0.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pipecatcloud"
-version = "0.0.9"
+version = "0.0.10"
 requires-python = ">=3.10"
 description = "Cloud hosting for Pipecat AI applications"
 license = { text = "BSD 2-Clause License" }

pipecatcloud-0.0.10/src/pipecatcloud/__init__.py

@@ -0,0 +1,33 @@
+import os
+import sys
+
+from loguru import logger
+
+from .exception import (
+    AgentNotHealthyError,
+    AgentStartError,
+    AuthError,
+    ConfigError,
+    ConfigFileError,
+    Error,
+    InvalidError,
+)
+from .session import Session, SessionParams
+
+logger.remove()
+logger.add(sys.stderr, level=str(os.getenv("PCC_LOG_LEVEL", "INFO")))
+
+
+__all__ = [
+    # Session classes
+    "Session",
+    "SessionParams",
+    # Exception classes
+    "Error",
+    "ConfigFileError",
+    "AuthError",
+    "InvalidError",
+    "ConfigError",
+    "AgentNotHealthyError",
+    "AgentStartError",
+]

pipecatcloud-0.0.10/src/pipecatcloud/_utils/console_utils.py

@@ -0,0 +1,124 @@
+from typing import Optional, Union
+
+from rich.console import Console
+from rich.panel import Panel
+
+from pipecatcloud.cli import PANEL_TITLE_ERROR, PANEL_TITLE_SUCCESS, PIPECAT_CLI_NAME
+
+
+class PipecatConsole(Console):
+    def success(
+            self,
+            message,
+            title: Optional[str] = None,
+            title_extra: Optional[str] = None,
+            subtitle: Optional[str] = None):
+
+        if not title:
+            title = f"{PANEL_TITLE_SUCCESS}{f' - {title_extra}' if title_extra is not None else ''}"
+
+        self.print(
+            Panel(
+                message,
+                title=f"[bold green]{title}[/bold green]",
+                subtitle=subtitle,
+                title_align="left",
+                subtitle_align="left",
+                border_style="green"))
+
+    def error(
+            self,
+            message,
+            title: Optional[str] = None,
+            title_extra: Optional[str] = None,
+            subtitle: Optional[str] = None):
+
+        if not title:
+            title = f"{PANEL_TITLE_ERROR}{f' - {title_extra}' if title_extra is not None else ''}"
+
+        self.print(
+            Panel(
+                message,
+                title=f"[bold red]{title}[/bold red]",
+                subtitle=subtitle,
+                title_align="left",
+                subtitle_align="left",
+                border_style="red"))
+
+    def cancel(self):
+        self.print("[yellow]Cancelled by user[/yellow]")
+
+    def unauthorized(self):
+        self.print(
+            Panel(
+                f"Unauthorized request / invalid user token.\n\nPlease log in again using [bold cyan]{PIPECAT_CLI_NAME} auth login[/bold cyan]",
+                title=f"[bold red]{PANEL_TITLE_ERROR} - Unauthorized (401)[/bold red]",
+                subtitle="",
+                title_align="left",
+                subtitle_align="left",
+                border_style="red"))
+
+    def api_error(
+            self,
+            error_code: Optional[Union[str, dict]] = None,
+            title: Optional[str] = "API Error",
+            hide_subtitle: bool = False):
+        DEFAULT_ERROR_MESSAGE = "Unknown error. Please contact support."
+
+        if isinstance(error_code, dict):
+            error_message = error_code.get("error", DEFAULT_ERROR_MESSAGE)
+            code = error_code.get("code")
+        else:
+            error_message = str(error_code) if error_code else DEFAULT_ERROR_MESSAGE
+            code = None
+
+        if not error_message:
+            hide_subtitle = True
+
+        self.print(
+            Panel(
+                f"[red]{title}[/red]\n\n"
+                f"[dim]Error message:[/dim]\n{error_message}",
+                title=f"[bold red]{PANEL_TITLE_ERROR}{f' - {code}' if code else ''}[/bold red]",
+                subtitle=f"[dim]Docs: https://docs.pipecat.daily.co/agents/error-codes#{code}[/dim]" if not hide_subtitle and code else None,
+                title_align="left",
+                subtitle_align="left",
+                border_style="red"))
+
+
+console = PipecatConsole()
+
+
+def format_timestamp(timestamp: str) -> str:
+    """
+    Format a timestamp string to a more readable format.
+    Handles timestamps with variable microsecond precision.
+
+    Args:
+        timestamp (str): The timestamp string in ISO format with microseconds (e.g. "2024-01-01T12:34:56.789Z")
+
+    Returns:
+        str: The formatted timestamp string
+    """
+    from datetime import datetime
+
+    # First try parsing the timestamp directly
+    try:
+        return datetime.strptime(timestamp, "%Y-%m-%dT%H:%M:%S.%fZ").strftime("%Y-%m-%d %H:%M:%S")
+    except ValueError:
+        pass
+
+    # Handle case where microseconds have higher precision
+    try:
+        parts = timestamp.split(".")
+        if len(parts) == 2 and parts[1].endswith("Z"):
+            # Truncate microseconds to 6 digits
+            microseconds = parts[1][:-1][:6].ljust(6, '0')
+            normalized = f"{parts[0]}.{microseconds}Z"
+            return datetime.strptime(normalized,
+                                     "%Y-%m-%dT%H:%M:%S.%fZ").strftime("%Y-%m-%d %H:%M:%S")
+    except (ValueError, IndexError):
+        pass
+
+    # Return original if parsing fails
+    return timestamp

{pipecatcloud-0.0.9 → pipecatcloud-0.0.10}/src/pipecatcloud/api.py

@@ -62,7 +62,18 @@ class _API():
             if not response.ok:
                 if not_found_is_empty and response.status == 404:
                     return None
-                self.error = response.status
+
+                # Extract PCC error code, where applicable
+                if response.status == 400:
+                    try:
+                        error_data = await response.json()
+                        self.error = error_data
+                    except Exception as e:
+                        # Fallback structure matching API format
+                        self.error = {"error": "Bad Request", "code": str(response.status)}
+                else:
+                    # Match API error format for non-400 errors
+                    self.error = {"error": response.reason, "code": str(response.status)}
                 response.raise_for_status()
 
             return await response.json()
@@ -91,14 +102,12 @@ class _API():
     def print_error(self):
         from pipecatcloud._utils.console_utils import console
 
-        # @TODO: handle coded errors here
-
         if not self.error:
             return
-        if self.error == 401:
+        if isinstance(self.error, dict) and self.error.get("code", "400") == "401":
             console.unauthorized()
         else:
-            console.api_error(str(self.error))
+            console.api_error(self.error)
 
     def bubble_error(self):
         self.bubble_next = True
@@ -362,3 +371,11 @@ class _API():
     @property
     def agent_delete(self):
         return self.create_api_method(self._agent_delete)
+
+    async def _agent_logs(self, agent_name: str, org: str, limit: int = 100) -> dict | None:
+        url = f"{self.construct_api_url('services_logs_path').format(org=org, service=agent_name)}"
+        return await self._base_request("GET", url, params={"limit": limit})
+
+    @property
+    def agent_logs(self):
+        return self.create_api_method(self._agent_logs)

{pipecatcloud-0.0.9 → pipecatcloud-0.0.10}/src/pipecatcloud/cli/commands/agent.py

@@ -3,15 +3,17 @@ import questionary
 import typer
 from loguru import logger
 from rich import box
-from rich.console import Console, Group
+from rich.console import Group
+from rich.columns import Columns
 from rich.live import Live
 from rich.panel import Panel
 from rich.table import Table
+from rich.text import Text
 
-from pipecatcloud._utils.agent_utils import handle_agent_start_error
+from enum import Enum
 from pipecatcloud._utils.async_utils import synchronizer
 from pipecatcloud._utils.auth_utils import requires_login
-from pipecatcloud._utils.console_utils import console
+from pipecatcloud._utils.console_utils import console, format_timestamp
 from pipecatcloud.cli import PIPECAT_CLI_NAME
 from pipecatcloud.cli.api import API
 from pipecatcloud.cli.config import config
@@ -104,29 +106,6 @@ async def status(
             console.error(f"No deployment data found for agent with name '{agent_name}'")
             return typer.Exit()
 
-        # Conditions
-        conditions = data["conditions"]
-        table = Table(
-            show_header=True,
-            show_lines=True,
-            border_style="dim",
-            box=box.SIMPLE
-        )
-        table.add_column("Status")
-        table.add_column("Type")
-        table.add_column("Message")
-        table.add_column("Reason")
-        table.add_column("Date")
-
-        for condition in conditions:
-            table.add_row(
-                DEPLOY_STATUS_MAP.get(condition["status"], "[dim]Unknown[/dim]"),
-                condition['type'],
-                condition.get('message', 'No message'),
-                condition.get('reason', 'No reason'),
-                condition['lastTransitionTime']
-            )
-
         # Deployment info
 
         deployment_table = Table(
@@ -136,14 +115,14 @@ async def status(
         )
         deployment_table.add_column("Key")
         deployment_table.add_column("Value")
-        deployment_table.add_row(
-            "[bold]Image:[/bold]",
-            str(data.get("deployment", {}).get("manifest", {}).get("spec", {}).get("image", "N/A")),
-        )
         deployment_table.add_row(
             "[bold]Active Session Count:[/bold]",
             str(data.get("activeSessionCount", "N/A")),
         )
+        deployment_table.add_row(
+            "[bold]Image:[/bold]",
+            str(data.get("deployment", {}).get("manifest", {}).get("spec", {}).get("image", "N/A")),
+        )
         deployment_table.add_row(
             "[bold]Active Deployment ID:[/bold]",
             str(data.get("activeDeploymentId", "N/A")),
@@ -160,24 +139,17 @@ async def status(
         # Autoscaling info
         autoscaling_data = data.get("autoScaling", None)
         if autoscaling_data:
-            autoscaling_table = Table(
-                show_header=False,
-                show_lines=False,
-                box=box.SIMPLE
-            )
-            autoscaling_table.add_column("Key")
-            autoscaling_table.add_column("Value")
-
-            autoscaling_table.add_row(
-                "[bold]Max instances:[/bold]",
-                str(autoscaling_data.get("maxReplicas", 0)),
-            )
-            autoscaling_table.add_row(
-                "[bold]Min instances:[/bold]",
-                str(autoscaling_data.get("minReplicas", 0)),
-            )
-            autoscaling_panel = Panel(
-                autoscaling_table,
+            scaling_renderables = [
+                Panel(
+                    f"[bold]Minimum Instances[/bold]\n{autoscaling_data.get('minReplicas', 0)}",
+                    expand=True),
+                Panel(
+                    f"[bold]Maximum Instances[/bold]\n{autoscaling_data.get('maxReplicas', 0)}",
+                    expand=True)]
+            scaling_panel = Panel(
+                Columns(
+                    scaling_renderables
+                ),
                 title="[bold]Scaling configuration:[/bold]",
                 title_align="left",
                 border_style="dim",
@@ -190,8 +162,7 @@ async def status(
             Panel(
                 Group(
                     deployment_table,
-                    autoscaling_panel if autoscaling_panel else "",
-                    table,
+                    scaling_panel if scaling_panel else "",
                     Panel(
                         f"[{color}]Health: {'Ready' if data['ready'] else 'Stopped'}[/]",
                         border_style="green" if data['ready'] else "yellow",
@@ -252,31 +223,69 @@ async def scale():
     console.error("Not implemented")
 
 
+class LogLevel(str, Enum):
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+class LogLevelColors(str, Enum):
+    DEBUG = "dim white"
+    INFO = "white"
+    WARNING = "yellow"
+    ERROR = "red"
+    CRITICAL = "bold red"
+
+
 @agent_cli.command(name="logs", help="Get logs for the given agent.")
 @synchronizer.create_blocking
 @requires_login
-async def logs(ctx: typer.Context, agent_name: str, organization: str = typer.Option(
-    None,
-    "--organization",
-    "-o",
-    help="Organization to get status of agent for"
-),):
+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"
+    ),
+    limit: int = typer.Option(
+        100,
+        "--limit", "-n",
+        help="Number of logs to get"
+    ),
+):
     org = organization or config.get("org")
-    token = config.get("token")
 
-    try:
-        with console.status(f"Fetching logs for agent: [bold]'{agent_name}'[/bold]", spinner="dots"):
-            async with aiohttp.ClientSession() as session:
-                response = await session.get(
-                    f"{API.construct_api_url('services_logs_path').format(org=org, service=agent_name)}?limit=100&order=desc",
-                    headers={"Authorization": f"Bearer {token}"},
-                )
-                if response.status != 200:
-                    response.raise_for_status()
-                data = await response.json()
-                console.print(data)
-    except Exception:
-        console.error(f"Unable to get logs for {agent_name}")
+    with console.status(f"[dim]Fetching logs for agent: [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)
+
+        if not data or not data.get("logs"):
+            console.print("[dim]No logs found for agent[/dim]")
+            return typer.Exit(1)
+
+    for l in data["logs"]:
+        log_data = l.get("log", "")
+        if log_data:
+            timestamp = format_timestamp(l.get("timestamp", ""))
+            severity = LogLevel.INFO
+            for log_severity in LogLevel:
+                if log_severity.value in log_data.upper():
+                    severity = log_severity
+                    break
+            # filter out any messages that do not match our log level
+            if level and severity.value != level.value:
+                continue
+            color = getattr(LogLevelColors, severity, LogLevelColors.DEBUG).value
+            console.print(Text(timestamp, style="bold dim"))
+            console.print(Text(l.get("log", ""), style=color))
+            console.rule(style="dim")
 
 
 @agent_cli.command(name="delete", help="Delete an agent.")
@@ -486,7 +495,7 @@ async def start(
             daily_room = data.get("dailyRoom")
             daily_token = data.get("dailyToken")
             if daily_room:
-                message += f"\n\nDaily room: [link={daily_room}?t={daily_token}]{daily_room}?t={daily_token}[/link]"
+                message += f"\n\nDaily room: [link={daily_room}?t={daily_token}]{daily_room}?t={daily_token}[/link]\n"
             return console.success(
                 message,
                 subtitle=f"[white dim]Join the session:[/white dim] [link={daily_room}?t={daily_token}]click here[/link]")

{pipecatcloud-0.0.9 → pipecatcloud-0.0.10}/src/pipecatcloud/cli/commands/deploy.py

@@ -32,7 +32,7 @@ async def _deploy(params: DeployConfigParams, org, force: bool = False):
     existing_agent = False
 
     # Check for an existing deployment with this agent name
-    with Live(console.status("[dim]Checking for exist agent deployment...[/dim]", spinner="dots")) as live:
+    with Live(console.status("[dim]Checking for existing agent deployment...[/dim]", spinner="dots")) as live:
         data, error = await API.agent(agent_name=params.agent_name, org=org, live=live)
 
         if error:
@@ -106,7 +106,6 @@ async def _deploy(params: DeployConfigParams, org, force: bool = False):
         # 3. Poll status until healthy
         """
         attempts = 0
-        condition_table = None
         active_deployment_id = None
         has_failed = False
         is_ready = False
@@ -117,8 +116,7 @@ async def _deploy(params: DeployConfigParams, org, force: bool = False):
                     Padding(
                         console.status(
                             f"[dim]Watching for deployment status (attempt: {attempts + 1})[dim]" if not active_deployment_id else f"Waiting for deployment to enter ready state [dim](attempt: {attempts + 1})[/dim]",
-                            spinner="bouncingBar"), (1, 0)),
-                    *([] if condition_table is None else [condition_table])
+                            spinner="bouncingBar"), (1, 0))
                 ),
                 title=f"[bold]{'Deploying' if not existing_agent else 'Updating'} agent[/bold]",
                 border_style="dim" if not active_deployment_id else "white",
@@ -141,34 +139,6 @@ async def _deploy(params: DeployConfigParams, org, force: bool = False):
                     attempts = 0
                     active_deployment_id = status["activeDeploymentId"]
 
-                # Update status display
-                conditions = status["conditions"]
-                table = Table(
-                    show_header=False,
-                    show_lines=True,
-                    border_style="dim",
-                    box=box.MINIMAL
-                )
-                table.add_column("Status")
-                table.add_column("Type")
-                table.add_column("Reason")
-
-                for condition in conditions:
-                    c_status = DEPLOY_STATUS_MAP.get(condition["status"], "[dim]Unknown[/dim]")
-                    if condition.get('reason') == "RevisionFailed":
-                        c_status = "[red]Failded[/red]"
-                        has_failed = condition
-                    if condition["type"] == "Ready":
-                        continue
-                    table.add_row(
-                        c_status,
-                        condition['type'],
-                        condition.get(
-                            'reason',
-                            'No reason'),
-                    )
-                condition_table = table
-
                 # Deployment is ready
                 if status["ready"]:
                     live.update("")

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

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

{pipecatcloud-0.0.9 → pipecatcloud-0.0.10}/src/pipecatcloud/cli/commands/secrets.py

@@ -212,13 +212,6 @@ async def set(
             if not create:
                 console.print("[bold red]Secret set creation cancelled[/bold red]")
                 return typer.Exit(1)
-    else:
-        if not skip_confirm:
-            create = await questionary.confirm(
-                f"Secret set with name '{name}' does not exist. Would you like to create it?").ask_async()
-            if not create:
-                console.print("[bold red]Secret set creation cancelled[/bold red]")
-                return typer.Exit(1)
 
     with console.status(f"[dim]{'Modifying' if existing_set else 'Creating'} secret set [bold]'{name}'[/bold][/dim]", spinner="dots"):
         for key, value in secrets_dict.items():

{pipecatcloud-0.0.9 → pipecatcloud-0.0.10}/src/pipecatcloud/config.py

@@ -12,6 +12,7 @@ class _Setting(typing.NamedTuple):
 _SETTINGS = {
     "api_host": _Setting("https://api.pipecat.daily.co"),
     "dashboard_host": _Setting("https://pipecat.daily.co"),
+    "init_zip_url": _Setting("https://github.com/daily-co/pipecat-cloud-starter/archive/refs/heads/main.zip"),
     "onboarding_path": _Setting("/v1/onboarding"),
     "login_path": _Setting("/auth/login"),
     "login_status_path": _Setting("/auth/status"),
@@ -22,8 +23,7 @@ _SETTINGS = {
     "services_deployments_path": _Setting("/v1/organizations/{org}/services/{service}/deployments"),
     "start_path": _Setting("/v1/public/{service}/start"),
     "api_keys_path": _Setting("/v1/organizations/{org}/apiKeys"),
-    "secrets_path": _Setting("/v1/organizations/{org}/secrets")
-}
+    "secrets_path": _Setting("/v1/organizations/{org}/secrets")}
 
 
 class Config:

{pipecatcloud-0.0.9 → pipecatcloud-0.0.10}/src/pipecatcloud/exception.py

@@ -1,6 +1,4 @@
-from typing import Optional
-
-from pipecatcloud.errors import ERROR_CODES
+from typing import Optional, Union
 
 
 class Error(Exception):
@@ -48,12 +46,16 @@ class AgentStartError(Error):
 
     def __init__(
             self,
-            message: str = "Agent start request failed.",
-            error_code: Optional[str] = None):
-
-        error_message = message if not error_code else ERROR_CODES.get(
-            error_code, message)
-
-        self.message = f"{error_message} (Error code: {error_code})"
-        self.error_code = error_code
+            error: Optional[Union[str, dict]] = None):
+
+        if isinstance(error, dict):
+            error_message = error.get("error", "Unknown error. Please contact support.")
+            code = error.get("code")
+        else:
+            error_message = str(
+                error) if error else "Unknown error. Please contact support."
+            code = None
+
+        self.message = f"{code} - {error_message}"
+        self.error_code = code
         super().__init__(self.message)

{pipecatcloud-0.0.9 → pipecatcloud-0.0.10}/src/pipecatcloud/session.py

@@ -4,8 +4,7 @@ from typing import Optional
 import aiohttp
 from loguru import logger
 
-from pipecatcloud._utils.agent_utils import handle_agent_start_error
-from pipecatcloud.api import API
+from pipecatcloud.api import _API as API
 from pipecatcloud.exception import AgentStartError
 
 
@@ -32,28 +31,38 @@ class Session:
 
     async def start(self) -> bool:
         if not self.api_key:
-            raise AgentStartError(error_code="PCC-1002")
+            raise AgentStartError({"code": "PCC-1002", "error": "No API key provided"})
 
         logger.debug(f"Starting agent {self.agent_name}")
 
-        start_error_code = None
+        start_error = None
+
+        payload: dict = {"createDailyRoom": bool(self.params.use_daily)}
+        if self.params.data is not None:
+            payload["body"] = self.params.data
+
         try:
             async with aiohttp.ClientSession() as session:
                 response = await session.post(
                     f"{API.construct_api_url('start_path').format(service=self.agent_name)}",
                     headers={"Authorization": f"Bearer {self.api_key}"},
-                    json={
-                        "createDailyRoom": bool(self.params.use_daily),
-                        "body": self.params.data
-                    }
+                    json=payload
                 )
+
                 if response.status != 200:
-                    start_error_code = handle_agent_start_error(response.status)
+                    # Attempt to parse the error code from the response
+                    try:
+                        error_data = await response.json()
+                        start_error = error_data
+                    except Exception:
+                        start_error = {"code": "PCC-1000",
+                                       "error": "Unknown error occurred. Please contact support."}
+
                     response.raise_for_status()
                 else:
                     logger.debug(f"Agent {self.agent_name} started successfully")
         except Exception as e:
             logger.error(f"Error starting agent {self.agent_name}: {e}")
-            raise AgentStartError(error_code=start_error_code)
+            raise AgentStartError(error=start_error)
 
         return True

{pipecatcloud-0.0.9 → pipecatcloud-0.0.10}/src/pipecatcloud.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pipecatcloud
-Version: 0.0.9
+Version: 0.0.10
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.daily.co/
@@ -70,16 +70,26 @@ pcc auth login
 
 ### Usage in Python scripts
 
-If want to programmatically start an agent within a Python script, you can use the `pipecatcloud.agent` module.
+If want to programmatically start an agent within a Python script, you can use the `pipecatcloud.session` module.
 
 ```python
-from pipecatcloud.agent import Agent
-
-agent = Agent(
-    agent_name="your-agent-name",
-    organization="your-organization",
-    api_key="your-api-key",
-)
-
-await agent.start()
+from pipecatcloud.session import Session
+from pipecatcloud.exception import AgentStartError
+import asyncio
+
+async def main():
+    session = Session(
+        agent_name="your-agent-name",
+        api_key="pk_...",
+    )
+
+    try:
+        await session.start()
+    except AgentStartError as e:
+        print(e)
+    except Exception as e:
+        raise (e)
+
+if __name__ == "__main__":
+    asyncio.run(main())
 ```

{pipecatcloud-0.0.9 → pipecatcloud-0.0.10}/src/pipecatcloud.egg-info/SOURCES.txt

@@ -15,7 +15,6 @@ src/pipecatcloud/__main__.py
 src/pipecatcloud/__version__.py
 src/pipecatcloud/api.py
 src/pipecatcloud/config.py
-src/pipecatcloud/errors.py
 src/pipecatcloud/exception.py
 src/pipecatcloud/session.py
 src/pipecatcloud.egg-info/PKG-INFO
@@ -25,7 +24,6 @@ src/pipecatcloud.egg-info/entry_points.txt
 src/pipecatcloud.egg-info/requires.txt
 src/pipecatcloud.egg-info/top_level.txt
 src/pipecatcloud/_utils/__init__.py
-src/pipecatcloud/_utils/agent_utils.py
 src/pipecatcloud/_utils/async_utils.py
 src/pipecatcloud/_utils/auth_utils.py
 src/pipecatcloud/_utils/console_utils.py

pipecatcloud-0.0.9/src/pipecatcloud/__init__.py

@@ -1,7 +0,0 @@
-import os
-import sys
-
-from loguru import logger
-
-logger.remove()
-logger.add(sys.stderr, level=str(os.getenv("PCC_LOG_LEVEL", "INFO")))

pipecatcloud-0.0.9/src/pipecatcloud/_utils/agent_utils.py

@@ -1,9 +0,0 @@
-def handle_agent_start_error(response_code: int) -> str:
-    if response_code == 404:
-        return "PCC-1005"
-    elif response_code == 400:
-        return "PCC-1004"
-    elif response_code == 401:
-        return "PCC-1006"
-    else:
-        return "PCC-1000"

pipecatcloud-0.0.9/src/pipecatcloud/_utils/console_utils.py

@@ -1,78 +0,0 @@
-from typing import Optional
-
-from rich.console import Console
-from rich.panel import Panel
-
-from pipecatcloud.cli import PANEL_TITLE_ERROR, PANEL_TITLE_SUCCESS
-from pipecatcloud.errors import ERROR_CODES
-
-
-class PipecatConsole(Console):
-    def success(
-            self,
-            message,
-            title: Optional[str] = None,
-            title_extra: Optional[str] = None,
-            subtitle: Optional[str] = None):
-
-        if not title:
-            title = f"{PANEL_TITLE_SUCCESS}{f' - {title_extra}' if title_extra is not None else ''}"
-
-        self.print(
-            Panel(
-                message,
-                title=f"[bold green]{title}[/bold green]",
-                subtitle=subtitle,
-                title_align="left",
-                subtitle_align="left",
-                border_style="green"))
-
-    def error(
-            self,
-            message,
-            title: Optional[str] = None,
-            title_extra: Optional[str] = None,
-            subtitle: Optional[str] = None):
-
-        if not title:
-            title = f"{PANEL_TITLE_ERROR}{f' - {title_extra}' if title_extra is not None else ''}"
-
-        self.print(
-            Panel(
-                message,
-                title=f"[bold red]{title}[/bold red]",
-                subtitle=subtitle,
-                title_align="left",
-                subtitle_align="left",
-                border_style="red"))
-
-    def cancel(self):
-        self.print("[yellow]Cancelled by user[/yellow]")
-
-    def unauthorized(self):
-        self.api_error("401", "Unauthorized", hide_subtitle=True)
-
-    def api_error(
-            self,
-            error_code: Optional[str],
-            title: Optional[str] = "API Error",
-            hide_subtitle: bool = False):
-        DEFAULT_ERROR_MESSAGE = "Unknown error. Please contact support."
-        ERROR_MESSAGE = ERROR_CODES.get(error_code, None) if error_code else None
-
-        if not ERROR_MESSAGE:
-            hide_subtitle = True
-
-        error_message = ERROR_MESSAGE if ERROR_MESSAGE else DEFAULT_ERROR_MESSAGE
-        self.print(
-            Panel(
-                f"[red]{title}[/red]\n\n"
-                f"[dim]Error message:[/dim]\n{error_message}",
-                title=f"[bold red]{PANEL_TITLE_ERROR} - {error_code}[/bold red]",
-                subtitle=f"[dim]Docs: https://docs.pipecat.daily.co/agents/error-codes#{error_code}[/dim]" if not hide_subtitle else None,
-                title_align="left",
-                subtitle_align="left",
-                border_style="red"))
-
-
-console = PipecatConsole()

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

@@ -1,16 +0,0 @@
-import typer
-
-from pipecatcloud._utils.async_utils import synchronizer
-from pipecatcloud._utils.console_utils import console
-
-# ----- Run
-
-
-def create_init_command(app: typer.Typer):
-    @app.command(name="init", help="Initialize project directory with template files")
-    @synchronizer.create_blocking
-    async def init(
-
-    ):
-        console.error("Not yet implemented")
-    return init

pipecatcloud-0.0.9/src/pipecatcloud/errors.py

@@ -1,11 +0,0 @@
-ERROR_CODES = {
-    "401": "Unauthorized request to API. Please run `pcc auth login` to login again.\nIf you are attempting to start an agent, please ensure the public API key used as part of the request is valid.",
-    "404": "API endpoint not found / namespace or organization not found.",
-    "PCC-1000": "Unable to start agent.",
-    "PCC-1001": "Attempt to start agent when deployment is not in ready state",
-    "PCC-1002": "Attempt to start agent without public api key. Try running `pcc organizations keys use`.",
-    "PCC-1003": "Unknown error occurred. Please check logs for more information.",
-    "PCC-1004": "Billing credentials not set. Please set billing credentials via the Pipecat Cloud dashboard.",
-    "PCC-1005": "Agent deployment with name not found.",
-    "PCC-1006": "Not authorized / invalid API key.",
-}