applied-cli 0.5.53__tar.gz → 0.5.55__tar.gz

{applied_cli-0.5.53 → applied_cli-0.5.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: applied-cli
-Version: 0.5.53
+Version: 0.5.55
 Summary: CLI and shared client library for Applied Labs AI support agents
 Author: Applied Labs
 License-Expression: MIT

{applied_cli-0.5.53 → applied_cli-0.5.55}/applied_cli/cli.py

@@ -1836,6 +1836,23 @@ def audit_rating_set_value(
     typer.echo(result)
 
 
+@app.command("connector-types")
+def connector_types(
+    type: str = typer.Option(
+        None, "--type", "-t", help="Filter to specific connector (e.g. shopify, zendesk)"
+    ),
+    format: str = typer.Option(
+        "text", "--format", "-f", help="Output format: text, csv, or json"
+    ),
+) -> None:
+    """List available connector types and their supported actions."""
+    client = get_client()
+    result = asyncio.run(
+        tools.connector_types(client, connector_type=type, output_format=format)
+    )
+    typer.echo(result)
+
+
 def main() -> None:
     """CLI entrypoint."""
     nested_exit_code = run_agent_scoped_flow_command(sys.argv[1:], get_client)

{applied_cli-0.5.53 → applied_cli-0.5.55}/applied_cli/client.py

@@ -431,6 +431,24 @@ class AppliedClient:
         )
         return self._normalize_response(data)
 
+    # -------------------------------------------------------------------------
+    # Connector Types
+    # -------------------------------------------------------------------------
+
+    async def list_connector_types(
+        self,
+        connector_type: str | None = None,
+        include_schemas: bool = False,
+    ) -> list[dict]:
+        """List available connector types and their supported actions."""
+        params: dict[str, Any] = {}
+        if connector_type:
+            params["type"] = connector_type
+        if include_schemas:
+            params["include_schemas"] = "true"
+        data = await self._request("GET", "/v2/connectors/types/", params=params)
+        return data if isinstance(data, list) else data.get("results", [data])
+
     # -------------------------------------------------------------------------
     # Taxonomy (topics, intents, flags)
     # -------------------------------------------------------------------------
@@ -1156,6 +1174,7 @@ class AppliedClient:
         source_handle: str | None = None,
         target_handle: str | None = None,
         label: str | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> dict:
         """Create an edge connecting two nodes."""
         body: dict[str, Any] = {
@@ -1168,6 +1187,8 @@ class AppliedClient:
             body["target_handle"] = target_handle
         if label:
             body["label"] = label
+        if metadata:
+            body["metadata"] = metadata
 
         return await self._request(
             "POST",

{applied_cli-0.5.53 → applied_cli-0.5.55}/applied_cli/flow_helpers.py

@@ -28,6 +28,7 @@ _CANONICAL_EXECUTOR_TYPES: tuple[str, ...] = (
     "mutate_ticket",
     "mutate_conversation",
     "mutate_message",
+    "end_conversation",
 )
 
 _EXECUTOR_UI_LABELS: dict[str, str] = {
@@ -49,6 +50,7 @@ _EXECUTOR_UI_LABELS: dict[str, str] = {
     "mutate_ticket": "Ticket",
     "mutate_conversation": "Conversation",
     "mutate_message": "Add Message",
+    "end_conversation": "End Conversation",
 }
 
 _EXECUTOR_ALIASES: dict[str, tuple[str, ...]] = {
@@ -70,6 +72,7 @@ _EXECUTOR_ALIASES: dict[str, tuple[str, ...]] = {
     "mutate_ticket": ("ticket",),
     "mutate_conversation": ("conversation",),
     "mutate_message": ("add message",),
+    "end_conversation": ("end conversation", "end call", "close conversation"),
 }
 
 _BRANCH_DEFAULT_ALIASES = {

{applied_cli-0.5.53 → applied_cli-0.5.55}/applied_cli/tools.py

@@ -2500,6 +2500,9 @@ async def flow_edge_create(
     branch: str | int | None = None,
     target_handle: str | None = None,
     label: str | None = None,
+    metadata: dict | None = None,
+    temporal_timeout_seconds: int | None = None,
+    temporal_disabled_contact_groups: dict | None = None,
 ) -> str:
     """
     Connect two nodes with an edge.
@@ -2513,7 +2516,14 @@ async def flow_edge_create(
         branch: Branch path alias for conversational branch nodes, e.g. "1",
             "branch 2", or "default". Preferred over source_handle for branch nodes.
         target_handle: Input handle name (for mapping)
-        label: Edge label/condition
+        label: Edge label/condition describing when to traverse this edge
+        metadata: Edge metadata dict. For temporal edges, include a "temporal"
+            key (or use the temporal_* convenience params below).
+        temporal_timeout_seconds: Convenience param to create a temporal edge
+            that auto-fires after this many seconds of inactivity.
+        temporal_disabled_contact_groups: Optional dict of contact group
+            overrides for the temporal edge, e.g.
+            {"__default__": false, "<group_id>": true}.
 
     Returns:
         Created edge
@@ -2523,6 +2533,14 @@ async def flow_edge_create(
 
     resolved_source_handle = normalize_branch_handle(branch or source_handle)
 
+    # Build metadata with temporal settings
+    metadata = dict(metadata or {})
+    if temporal_timeout_seconds is not None:
+        temporal = metadata.setdefault("temporal", {})
+        temporal["timeout_seconds"] = temporal_timeout_seconds
+        if temporal_disabled_contact_groups is not None:
+            temporal["disabled_contact_groups"] = temporal_disabled_contact_groups
+
     try:
         flow = await client.get_flow(flow_id)
     except AppliedAPIError as e:
@@ -2589,6 +2607,7 @@ async def flow_edge_create(
             source_handle=resolved_source_handle,
             target_handle=target_handle,
             label=label,
+            metadata=metadata or None,
         )
     except AppliedAPIError as e:
         # Add extra context for edge errors
@@ -2602,14 +2621,33 @@ async def flow_edge_create(
             )
         return _format_error(e) + extra
 
+    edge_id = edge.get("id")
+
+    # Follow-up update to persist label and metadata (backend create
+    # endpoint may not pass these through to the model).
+    needs_update = label or metadata
+    if needs_update and edge_id:
+        updates: dict = {}
+        if label:
+            updates["label"] = label
+        if metadata:
+            updates["metadata"] = metadata
+        try:
+            edge = await client.update_edge(flow_id, edge_id, **updates)
+        except AppliedAPIError:
+            pass  # best-effort; edge was already created
+
     result = "# Created Edge\n"
-    result += f"id: {edge.get('id')}\n"
+    result += f"id: {edge_id}\n"
     result += f"source: {edge.get('source')}\n"
     result += f"target: {edge.get('target')}\n"
     if resolved_source_handle is not None:
         result += f"source_handle: {resolved_source_handle}\n"
     if label:
         result += f"label: {label}\n"
+    if metadata.get("temporal"):
+        temporal = metadata["temporal"]
+        result += f"temporal_timeout_seconds: {temporal.get('timeout_seconds')}\n"
     result += "\nTip: run flow_layout(flow_id) after wiring a complex flow to tidy node positions.\n"
 
     return result
@@ -2666,6 +2704,8 @@ async def flow_edge_update(
     edge_id: str,
     label: str | None = None,
     metadata: dict | None = None,
+    temporal_timeout_seconds: int | None = None,
+    temporal_disabled_contact_groups: dict | None = None,
 ) -> str:
     """
     Update an edge's properties.
@@ -2674,21 +2714,39 @@ async def flow_edge_update(
         client: Authenticated AppliedClient
         flow_id: The flow UUID
         edge_id: The edge UUID
-        label: New label/condition
-        metadata: New metadata
+        label: New label/condition describing when to traverse this edge
+        metadata: New metadata dict. For temporal edges, include a "temporal"
+            key or use the temporal_* convenience params.
+        temporal_timeout_seconds: Set/update the temporal timeout in seconds.
+            Makes this edge auto-fire after inactivity.
+        temporal_disabled_contact_groups: Contact group overrides for the
+            temporal edge, e.g. {"__default__": false, "<group_id>": true}.
 
     Returns:
         Updated edge
     """
-    updates = {}
+    metadata = dict(metadata or {}) if metadata else {}
+    if temporal_timeout_seconds is not None:
+        temporal = metadata.setdefault("temporal", {})
+        temporal["timeout_seconds"] = temporal_timeout_seconds
+        if temporal_disabled_contact_groups is not None:
+            temporal["disabled_contact_groups"] = temporal_disabled_contact_groups
+
+    updates: dict = {}
     if label is not None:
         updates["label"] = label
-    if metadata is not None:
+    if metadata:
         updates["metadata"] = metadata
 
     edge = await client.update_edge(flow_id, edge_id, **updates)
 
-    return f"# Updated Edge\nid: {edge.get('id')}"
+    result = f"# Updated Edge\nid: {edge.get('id')}"
+    if label is not None:
+        result += f"\nlabel: {label}"
+    if metadata.get("temporal"):
+        temporal = metadata["temporal"]
+        result += f"\ntemporal_timeout_seconds: {temporal.get('timeout_seconds')}"
+    return result
 
 
 async def flow_edge_delete(
@@ -3518,6 +3576,92 @@ async def send_message(
         return f"Error sending message: {e}"
 
 
+async def connector_types(
+    client: AppliedClient,
+    connector_type: str | None = None,
+    output_format: str = "text",
+) -> str:
+    """
+    List available connector types and their supported actions.
+
+    Args:
+        client: Authenticated AppliedClient
+        connector_type: Optional filter to a specific connector (e.g. 'shopify')
+        output_format: 'text' (default), 'csv' (summary), 'json' (raw)
+
+    Returns:
+        Connector types with their available actions and metadata
+    """
+    try:
+        data = await client.list_connector_types(
+            connector_type=connector_type,
+            include_schemas=(output_format == "json"),
+        )
+    except Exception as e:
+        return f"Error listing connector types: {e}"
+
+    if output_format == "json":
+        return to_json(data)
+
+    if output_format == "csv":
+        rows = []
+        for connector in data:
+            for action in connector.get("actions", []):
+                rows.append(
+                    {
+                        "connector": connector["name"],
+                        "action": action["name"],
+                        "description": action.get("description", ""),
+                        "parameters": ", ".join(
+                            p["name"] for p in action.get("parameters", [])
+                        ),
+                    }
+                )
+        return to_csv(rows, ["connector", "action", "description", "parameters"])
+
+    # Default: text output
+    if not data:
+        return "No connector types found."
+
+    result = "# Available Connector Types\n\n"
+    result += (
+        "Use with: flow_node_create(executor_type='resource', "
+        "metadata={'resource_type': '<connector>', 'action': '<action>', "
+        "'resource_id': '<uuid>'})\n\n"
+    )
+
+    for connector in data:
+        name = connector["name"]
+        action_count = connector.get("action_count", len(connector.get("actions", [])))
+        result += f"## {name} ({action_count} actions)\n\n"
+
+        for action in connector.get("actions", []):
+            result += f"  {action['name']}"
+            desc = action.get("description", "")
+            if desc:
+                # Show first line of description
+                first_line = desc.split("\n")[0].strip()
+                result += f" — {first_line}"
+            result += "\n"
+
+            params = action.get("parameters", [])
+            if params:
+                for p in params:
+                    req = " (required)" if p.get("required") else ""
+                    pline = f"    {p['name']}: {p.get('type', 'any')}{req}"
+                    if p.get("description"):
+                        pline += f" — {p['description']}"
+                    result += pline + "\n"
+
+            ret = action.get("return_type")
+            if ret:
+                result += f"    → {ret}\n"
+
+            result += "\n"
+
+    return result
+
+
 async def executor_list(
     client: AppliedClient,
     output_format: str = "full",

{applied_cli-0.5.53 → applied_cli-0.5.55}/applied_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: applied-cli
-Version: 0.5.53
+Version: 0.5.55
 Summary: CLI and shared client library for Applied Labs AI support agents
 Author: Applied Labs
 License-Expression: MIT

{applied_cli-0.5.53 → applied_cli-0.5.55}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "applied-cli"
-version = "0.5.53"
+version = "0.5.55"
 description = "CLI and shared client library for Applied Labs AI support agents"
 readme = "README.md"
 requires-python = ">=3.11"