simplex 3.0.2__tar.gz → 3.0.4__tar.gz

{simplex-3.0.2/simplex.egg-info → simplex-3.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplex
-Version: 3.0.2
+Version: 3.0.4
 Summary: Official Python SDK for the Simplex API
 Author-email: Simplex <support@simplex.sh>
 License: MIT

{simplex-3.0.2 → simplex-3.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simplex"
-version = "3.0.2"
+version = "3.0.4"
 description = "Official Python SDK for the Simplex API"
 readme = "README.md"
 requires-python = ">=3.9"

{simplex-3.0.2 → simplex-3.0.4}/simplex/__init__.py

@@ -43,7 +43,7 @@ from simplex.types import (
 )
 from simplex.webhook import WebhookVerificationError, verify_simplex_webhook
 
-__version__ = "3.0.2"
+__version__ = "3.0.4"
 __all__ = [
     "SimplexClient",
     "SimplexError",

{simplex-3.0.2 → simplex-3.0.4}/simplex/_http_client.py

@@ -21,7 +21,7 @@ from simplex.errors import (
     ValidationError,
 )
 
-__version__ = "3.0.2"
+__version__ = "3.0.4"
 
 
 class HttpClient:

simplex-3.0.4/simplex/cli/sessions.py

@@ -0,0 +1,250 @@
+"""Session commands: status, events, logs, download, replay."""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from simplex.cli.config import make_client_kwargs
+from simplex.cli.output import console, print_error, print_json, print_kv, print_success
+
+app = typer.Typer(help="Inspect sessions.")
+
+
+@app.command("status")
+def status(
+    session_id: str = typer.Argument(help="Session ID"),
+    watch: bool = typer.Option(False, "--watch", "-w", help="Poll until session completes"),
+) -> None:
+    """Get the status of a session."""
+    from simplex import SimplexClient, SimplexError
+
+    try:
+        client = SimplexClient(**make_client_kwargs())
+        result = client.get_session_status(session_id)
+    except SimplexError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    _print_status(result)
+
+    if not watch:
+        return
+
+    if not result.get("in_progress", False):
+        return
+
+    # Poll until complete
+    from rich.live import Live
+    from rich.spinner import Spinner
+
+    spinner = Spinner("dots", text="Waiting for session to complete...")
+    try:
+        with Live(spinner, console=console, refresh_per_second=4):
+            while True:
+                time.sleep(2)
+                try:
+                    result = client.get_session_status(session_id)
+                except SimplexError as e:
+                    print_error(str(e))
+                    raise typer.Exit(1)
+                if not result.get("in_progress", True):
+                    break
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Watch interrupted.[/yellow]")
+        raise typer.Exit(0)
+
+    console.print()
+    _print_status(result)
+
+    if not result.get("success", False):
+        raise typer.Exit(1)
+
+
+def _print_status(result: dict) -> None:
+    """Print session status fields."""
+    pairs = [
+        ("In Progress", result.get("in_progress", "")),
+        ("Success", result.get("success", "")),
+        ("Paused", result.get("paused", False)),
+    ]
+    if result.get("metadata"):
+        pairs.append(("Metadata", str(result["metadata"])))
+    if result.get("workflow_metadata"):
+        pairs.append(("Workflow Metadata", str(result["workflow_metadata"])))
+    if result.get("final_message"):
+        pairs.append(("Final Message", str(result["final_message"])))
+    print_kv(pairs)
+
+    outputs = result.get("scraper_outputs")
+    if outputs:
+        console.print("\n[bold]Outputs:[/bold]")
+        print_json(outputs)
+
+    structured = result.get("structured_output")
+    if structured:
+        console.print("\n[bold]Structured Output:[/bold]")
+        print_json(structured)
+
+    files = result.get("file_metadata")
+    if files:
+        console.print("\n[bold]Files:[/bold]")
+        for f in files:
+            size = f.get("file_size", 0)
+            if size >= 1_048_576:
+                size_str = f"{size / 1_048_576:.1f} MB"
+            elif size >= 1024:
+                size_str = f"{size / 1024:.1f} KB"
+            else:
+                size_str = f"{size} B"
+            print_kv([
+                ("Filename", f.get("filename", "")),
+                ("Size", size_str),
+                ("Downloaded", f.get("download_timestamp", "")),
+                ("URL", f.get("download_url", "")),
+            ])
+            console.print()
+
+
+@app.command("events")
+def events(
+    workflow_id: str = typer.Argument(help="Workflow ID"),
+    since: int = typer.Option(0, "--since", "-s", help="Event index to start from"),
+    limit: int = typer.Option(100, "--limit", "-l", help="Max events to return"),
+    json_output: bool = typer.Option(False, "--json", help="Output raw JSON"),
+) -> None:
+    """Poll events for a workflow's active session."""
+    from simplex import SimplexClient, SimplexError
+
+    try:
+        client = SimplexClient(**make_client_kwargs())
+    except (SimplexError, ValueError) as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    # Look up active session to get logs_url
+    try:
+        active = client.get_workflow_active_session(workflow_id)
+        logs_url = active.get("logs_url", "")
+    except SimplexError as e:
+        print_error(f"Could not find active session: {e}")
+        raise typer.Exit(1)
+
+    if not logs_url:
+        print_error(f"No active session found for workflow {workflow_id}")
+        raise typer.Exit(1)
+
+    try:
+        result = client.poll_events(logs_url, since=since, limit=limit)
+    except SimplexError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    if json_output:
+        print(json.dumps(result, indent=2, default=str), flush=True)
+        return
+
+    events_list = result.get("events", [])
+    next_idx = result.get("next_index", 0)
+    total = result.get("total", 0)
+    has_more = result.get("has_more", False)
+
+    for event in events_list:
+        etype = event.get("event", "")
+        if etype == "RunContent":
+            content = event.get("content", "")
+            if content and content != "SIMPLEX_AGENT_INITIALIZED":
+                console.print(content, end="", highlight=False)
+        elif etype == "ToolCallStarted":
+            tool = event.get("tool", {})
+            tool_name = tool.get("tool_name", "unknown") if isinstance(tool, dict) else "unknown"
+            console.print(f"  [cyan]>[/cyan] [bold]{tool_name}[/bold]")
+        elif etype == "ToolCallCompleted":
+            tool = event.get("tool", {})
+            if isinstance(tool, dict) and tool.get("tool_call_error"):
+                console.print(f"    [red]error: {str(tool.get('content', ''))[:200]}[/red]")
+        elif etype == "RunCompleted":
+            console.print(f"\n[bold green]Completed[/bold green]")
+        elif etype == "RunError":
+            console.print(f"\n[bold red]Error:[/bold red] {event.get('content', '')}")
+        elif etype == "RunStarted":
+            console.print("[dim]Agent started[/dim]\n")
+
+    console.print()
+    print_kv([
+        ("Next Index", next_idx),
+        ("Total", total),
+        ("Has More", has_more),
+    ])
+
+
+@app.command("logs")
+def logs(
+    session_id: str = typer.Argument(help="Session ID"),
+) -> None:
+    """Retrieve session logs."""
+    from simplex import SimplexClient, SimplexError
+
+    try:
+        client = SimplexClient(**make_client_kwargs())
+        result = client.retrieve_session_logs(session_id)
+    except SimplexError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    if result is None:
+        print_error("Session is still running — logs not yet available.")
+        raise typer.Exit(1)
+
+    print_json(result)
+
+
+@app.command("download")
+def download(
+    session_id: str = typer.Argument(help="Session ID"),
+    filename: Optional[str] = typer.Option(None, "--filename", "-f", help="Specific file to download"),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Output path"),
+) -> None:
+    """Download files from a session."""
+    from simplex import SimplexClient, SimplexError
+
+    try:
+        client = SimplexClient(**make_client_kwargs())
+        data = client.download_session_files(session_id, filename=filename)
+    except SimplexError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    if output:
+        out_path = Path(output)
+    elif filename:
+        out_path = Path(filename)
+    else:
+        out_path = Path(f"{session_id}_files.zip")
+
+    out_path.write_bytes(data)
+    print_success(f"Downloaded to {out_path}")
+
+
+@app.command("replay")
+def replay(
+    session_id: str = typer.Argument(help="Session ID"),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Output path"),
+) -> None:
+    """Download session replay video."""
+    from simplex import SimplexClient, SimplexError
+
+    try:
+        client = SimplexClient(**make_client_kwargs())
+        data = client.retrieve_session_replay(session_id)
+    except SimplexError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    out_path = Path(output) if output else Path(f"{session_id}_replay.mp4")
+    out_path.write_bytes(data)
+    print_success(f"Replay saved to {out_path}")

{simplex-3.0.2 → simplex-3.0.4}/simplex/client.py

@@ -13,12 +13,15 @@ from typing import Any
 from simplex._http_client import HttpClient
 from simplex.errors import WorkflowError
 from simplex.types import (
+    DeleteCredentialResponse,
+    ListCredentialsResponse,
     PauseSessionResponse,
     ResumeSessionResponse,
     RunWorkflowResponse,
     SearchWorkflowsResponse,
     SessionStatusResponse,
     StartEditorSessionResponse,
+    StoreCredentialResponse,
     UpdateWorkflowMetadataResponse,
 )
 
@@ -666,6 +669,84 @@ class SimplexClient:
         """
         return self._http_client.get(f"/workflow/{workflow_id}/active_session")
 
+    def store_credential(self, name: str, value: str) -> StoreCredentialResponse:
+        """
+        Store an encrypted credential for your organization.
+
+        The value is encrypted server-side and can later be used by the agent
+        via ``type_secret(credential_name="...")``.
+
+        Args:
+            name: A unique name for the credential
+            value: The plaintext value to encrypt and store
+
+        Returns:
+            StoreCredentialResponse with credential_id on success
+
+        Example:
+            >>> client.store_credential("github_token", "ghp_xxxx...")
+            {'succeeded': True, 'name': 'github_token', 'credential_id': '...'}
+        """
+        try:
+            response: StoreCredentialResponse = self._http_client.post_json(
+                "/store_credential",
+                data={"name": name, "value": value},
+            )
+            return response
+        except Exception as e:
+            if isinstance(e, WorkflowError):
+                raise
+            raise WorkflowError(f"Failed to store credential: {e}")
+
+    def list_credentials(self) -> ListCredentialsResponse:
+        """
+        List all encrypted credentials for your organization.
+
+        Returns metadata only (name, dates) -- not the encrypted values.
+
+        Returns:
+            ListCredentialsResponse with array of credential metadata
+
+        Example:
+            >>> result = client.list_credentials()
+            >>> for cred in result["credentials"]:
+            ...     print(f"{cred['name']} (created {cred['created_at']})")
+        """
+        try:
+            response: ListCredentialsResponse = self._http_client.get(
+                "/list_credentials",
+            )
+            return response
+        except Exception as e:
+            if isinstance(e, WorkflowError):
+                raise
+            raise WorkflowError(f"Failed to list credentials: {e}")
+
+    def delete_credential(self, name: str) -> DeleteCredentialResponse:
+        """
+        Delete an encrypted credential by name.
+
+        Args:
+            name: The name of the credential to delete
+
+        Returns:
+            DeleteCredentialResponse
+
+        Example:
+            >>> client.delete_credential("github_token")
+            {'succeeded': True}
+        """
+        try:
+            response: DeleteCredentialResponse = self._http_client.post_json(
+                "/delete_credential",
+                data={"name": name},
+            )
+            return response
+        except Exception as e:
+            if isinstance(e, WorkflowError):
+                raise
+            raise WorkflowError(f"Failed to delete credential: {e}")
+
     def close_session(self, session_id: str) -> Any:
         """
         Close a workflow session.

{simplex-3.0.2 → simplex-3.0.4}/simplex/types.py

@@ -182,6 +182,51 @@ class StartEditorSessionResponse(TypedDict, total=False):
     filesystem_url: str | None
 
 
+class StoreCredentialResponse(TypedDict, total=False):
+    """
+    Response from storing a credential.
+
+    Attributes:
+        succeeded: Whether the credential was stored successfully
+        name: The credential name
+        credential_id: The ID of the stored credential
+        error: Error message if the operation failed
+    """
+
+    succeeded: bool
+    name: str
+    credential_id: str
+    error: str
+
+
+class ListCredentialsResponse(TypedDict, total=False):
+    """
+    Response from listing credentials.
+
+    Attributes:
+        succeeded: Whether the list operation succeeded
+        credentials: List of credential metadata (id, name, created_at, updated_at)
+        error: Error message if the operation failed
+    """
+
+    succeeded: bool
+    credentials: list[dict[str, Any]]
+    error: str
+
+
+class DeleteCredentialResponse(TypedDict, total=False):
+    """
+    Response from deleting a credential.
+
+    Attributes:
+        succeeded: Whether the credential was deleted successfully
+        error: Error message if the operation failed
+    """
+
+    succeeded: bool
+    error: str
+
+
 class WebhookPayload(TypedDict, total=False):
     """
     Payload received from a Simplex webhook.

{simplex-3.0.2 → simplex-3.0.4/simplex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplex
-Version: 3.0.2
+Version: 3.0.4
 Summary: Official Python SDK for the Simplex API
 Author-email: Simplex <support@simplex.sh>
 License: MIT

simplex-3.0.2/simplex/cli/sessions.py

@@ -1,119 +0,0 @@
-"""Session commands: status, logs, download, replay."""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Optional
-
-import typer
-
-from simplex.cli.config import make_client_kwargs
-from simplex.cli.output import print_error, print_json, print_kv, print_success
-
-app = typer.Typer(help="Inspect sessions.")
-
-
-@app.command("status")
-def status(
-    session_id: str = typer.Argument(help="Session ID"),
-) -> None:
-    """Get the status of a session."""
-    from simplex import SimplexClient, SimplexError
-
-    try:
-        client = SimplexClient(**make_client_kwargs())
-        result = client.get_session_status(session_id)
-    except SimplexError as e:
-        print_error(str(e))
-        raise typer.Exit(1)
-
-    pairs = [
-        ("In Progress", result.get("in_progress", "")),
-        ("Success", result.get("success", "")),
-        ("Paused", result.get("paused", False)),
-    ]
-    if result.get("metadata"):
-        pairs.append(("Metadata", str(result["metadata"])))
-    print_kv(pairs)
-
-    outputs = result.get("scraper_outputs")
-    if outputs:
-        from rich.console import Console
-
-        Console().print("\n[bold]Outputs:[/bold]")
-        print_json(outputs)
-
-    structured = result.get("structured_output")
-    if structured:
-        from rich.console import Console
-
-        Console().print("\n[bold]Structured Output:[/bold]")
-        print_json(structured)
-
-
-@app.command("logs")
-def logs(
-    session_id: str = typer.Argument(help="Session ID"),
-) -> None:
-    """Retrieve session logs."""
-    from simplex import SimplexClient, SimplexError
-
-    try:
-        client = SimplexClient(**make_client_kwargs())
-        result = client.retrieve_session_logs(session_id)
-    except SimplexError as e:
-        print_error(str(e))
-        raise typer.Exit(1)
-
-    if result is None:
-        print_error("Session is still running — logs not yet available.")
-        raise typer.Exit(1)
-
-    print_json(result)
-
-
-@app.command("download")
-def download(
-    session_id: str = typer.Argument(help="Session ID"),
-    filename: Optional[str] = typer.Option(None, "--filename", "-f", help="Specific file to download"),
-    output: Optional[str] = typer.Option(None, "--output", "-o", help="Output path"),
-) -> None:
-    """Download files from a session."""
-    from simplex import SimplexClient, SimplexError
-
-    try:
-        client = SimplexClient(**make_client_kwargs())
-        data = client.download_session_files(session_id, filename=filename)
-    except SimplexError as e:
-        print_error(str(e))
-        raise typer.Exit(1)
-
-    if output:
-        out_path = Path(output)
-    elif filename:
-        out_path = Path(filename)
-    else:
-        out_path = Path(f"{session_id}_files.zip")
-
-    out_path.write_bytes(data)
-    print_success(f"Downloaded to {out_path}")
-
-
-@app.command("replay")
-def replay(
-    session_id: str = typer.Argument(help="Session ID"),
-    output: Optional[str] = typer.Option(None, "--output", "-o", help="Output path"),
-) -> None:
-    """Download session replay video."""
-    from simplex import SimplexClient, SimplexError
-
-    try:
-        client = SimplexClient(**make_client_kwargs())
-        data = client.retrieve_session_replay(session_id)
-    except SimplexError as e:
-        print_error(str(e))
-        raise typer.Exit(1)
-
-    out_path = Path(output) if output else Path(f"{session_id}_replay.mp4")
-    out_path.write_bytes(data)
-    print_success(f"Replay saved to {out_path}")