applied-cli 0.5.69__tar.gz → 0.5.71__tar.gz

{applied_cli-0.5.69 → applied_cli-0.5.71}/PKG-INFO

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

{applied_cli-0.5.69 → applied_cli-0.5.71}/applied_cli/__init__.py

@@ -4,6 +4,6 @@ from applied_cli import tools
 from applied_cli.client import AppliedClient
 from applied_cli.formatters import to_csv, to_json
 
-__version__ = "0.5.69"
+__version__ = "0.5.71"
 
 __all__ = ["AppliedClient", "tools", "to_csv", "to_json", "__version__"]

{applied_cli-0.5.69 → applied_cli-0.5.71}/applied_cli/cli.py

@@ -289,7 +289,7 @@ def analytics(
         "--group-by",
         "-g",
         help=(
-            "Comma-separated dimensions: label_name, sublabel_name, agent_name, "
+            "Comma-separated dimensions: topic, intent, label_name, sublabel_name, "
             "resolution, sentiment, type, user_id, label_id, sublabel_id, agent_id"
         ),
     ),
@@ -297,7 +297,7 @@ def analytics(
         "count",
         "--metrics",
         "-m",
-        help="Comma-separated metrics: count, avg_score, avg_ttr, resolution_rate",
+        help="Comma-separated metrics: count",
     ),
     filter: list[str] | None = typer.Option(  # noqa: B008
         None,

{applied_cli-0.5.69 → applied_cli-0.5.71}/applied_cli/client.py

@@ -192,6 +192,23 @@ _ANALYTICS_DIMENSION_SQL = {
     "type": "type",
     "user_id": "user_id",
 }
+_ANALYTICS_AUTOMATION_DIMENSIONS = {
+    "intent": "sublabel_name",
+    "label_id": "label_id",
+    "label_name": "label_name",
+    "sublabel_id": "sublabel_id",
+    "sublabel_name": "sublabel_name",
+    "topic": "label_name",
+}
+_ANALYTICS_DASHBOARD_DIMENSIONS = {
+    "agent_id": "agent_id",
+    "label_id": "label_id",
+    "resolution": "resolution",
+    "sentiment": "sentiment",
+    "sublabel_id": "sublabel_id",
+    "type": "type",
+    "user_id": "user_id",
+}
 _ANALYTICS_FILTER_SQL = {
     **_ANALYTICS_DIMENSION_SQL,
     "score": "score",
@@ -297,6 +314,52 @@ def _build_legacy_analytics_sql(
     return "\n".join(sql_parts)
 
 
+def _parse_legacy_analytics_filters(filters: list[str] | None) -> dict[str, Any]:
+    parsed: dict[str, Any] = {}
+    for raw_filter in filters or []:
+        if "=" not in raw_filter:
+            raise ValueError(f"Invalid analytics filter: {raw_filter}")
+        field, raw_value = raw_filter.split("=", 1)
+        field = field.strip()
+        if field not in _ANALYTICS_FILTER_SQL:
+            raise ValueError(f"Unsupported analytics filter field: {field}")
+        parsed[field] = _decode_filter_value(raw_value)
+    return parsed
+
+
+def _validate_analytics_count_metrics(metrics: list[str] | None) -> list[str]:
+    metric_names = metrics or ["count"]
+    unsupported = [metric for metric in metric_names if metric != "count"]
+    if unsupported:
+        raise ValueError(
+            "The current analytics endpoint only supports the count metric for "
+            "applied analytics. Use applied analytics-report for richer metrics."
+        )
+    return metric_names
+
+
+def _decode_dashboard_group(group: Any, expected_count: int) -> list[Any]:
+    if expected_count == 1:
+        return [group]
+    if isinstance(group, str):
+        try:
+            decoded = json.loads(group)
+        except json.JSONDecodeError:
+            decoded = group
+        if isinstance(decoded, list):
+            return decoded
+    if isinstance(group, list):
+        return group
+    return [group]
+
+
+def _sort_analytics_rows(rows: list[dict[str, Any]], group_by: list[str]) -> None:
+    def sort_key(row: dict[str, Any]) -> tuple[str, ...]:
+        return tuple("" if row.get(dimension) is None else str(row.get(dimension)) for dimension in group_by)
+
+    rows.sort(key=sort_key)
+
+
 class AppliedClient:
     """Async client for Applied Labs API."""
 
@@ -612,20 +675,154 @@ class AppliedClient:
         end: str | None = None,
         limit: int | None = None,
     ) -> dict:
-        """Run a GROUP BY query against conversation_latest_state."""
-        sql = _build_legacy_analytics_sql(
-            group_by=group_by,
-            metrics=metrics,
-            filters=filters,
-            start=start,
-            end=end,
-            limit=limit,
-        )
-        data = await self.analytics_sql(sql=sql, max_rows=limit)
+        """Run a grouped conversation count query through the analytics API."""
+        if not group_by:
+            raise ValueError("group_by is required")
+
+        metric_names = _validate_analytics_count_metrics(metrics)
+        parsed_filters = _parse_legacy_analytics_filters(filters)
+
+        if all(dimension in _ANALYTICS_AUTOMATION_DIMENSIONS for dimension in group_by):
+            data = await self._taxonomy_analytics_query(
+                group_by=group_by,
+                filters=parsed_filters,
+                start=start,
+                end=end,
+                limit=limit,
+            )
+        else:
+            data = await self._dashboard_analytics_query(
+                group_by=group_by,
+                filters=parsed_filters,
+                start=start,
+                end=end,
+                limit=limit,
+            )
+
         data["dimensions"] = group_by
-        data["metrics"] = metrics or ["count"]
+        data["metrics"] = metric_names
         return data
 
+    async def _taxonomy_analytics_query(
+        self,
+        *,
+        group_by: list[str],
+        filters: dict[str, Any],
+        start: str | None,
+        end: str | None,
+        limit: int | None,
+    ) -> dict:
+        payload: dict[str, Any] = {
+            "view": "automation_aggregates",
+            "model": "conversation",
+            **filters,
+        }
+        if start:
+            payload["start_date"] = start
+        if end:
+            payload["end_date"] = end
+
+        data = await self.analytics_report(payload)
+        source_key = (
+            "by_intent"
+            if any(
+                dimension in {"intent", "sublabel_id", "sublabel_name"}
+                for dimension in group_by
+            )
+            else "by_topic"
+        )
+
+        grouped: dict[tuple[Any, ...], int] = {}
+        for row in data.get(source_key, []):
+            key = tuple(
+                row.get(_ANALYTICS_AUTOMATION_DIMENSIONS[dimension])
+                for dimension in group_by
+            )
+            grouped[key] = grouped.get(key, 0) + int(row.get("total") or 0)
+
+        rows = [
+            {
+                **dict(zip(group_by, key, strict=False)),
+                "count": count,
+            }
+            for key, count in grouped.items()
+        ]
+        _sort_analytics_rows(rows, group_by)
+
+        total_rows = len(rows)
+        if limit is not None:
+            rows = rows[:limit]
+
+        return {
+            "columns": [*group_by, "count"],
+            "rows": rows,
+            "row_count": len(rows),
+            "truncated": limit is not None and total_rows > len(rows),
+        }
+
+    async def _dashboard_analytics_query(
+        self,
+        *,
+        group_by: list[str],
+        filters: dict[str, Any],
+        start: str | None,
+        end: str | None,
+        limit: int | None,
+    ) -> dict:
+        backend_group_by: list[str] = []
+        unsupported: list[str] = []
+        for dimension in group_by:
+            backend_dimension = _ANALYTICS_DASHBOARD_DIMENSIONS.get(dimension)
+            if backend_dimension is None:
+                unsupported.append(dimension)
+            else:
+                backend_group_by.append(backend_dimension)
+
+        if unsupported:
+            raise ValueError(
+                "Unsupported analytics dimension for the current endpoint: "
+                + ", ".join(unsupported)
+            )
+
+        payload: dict[str, Any] = {
+            "view": "dashboard_rate_metrics",
+            "model": "conversation",
+            "group_by": ",".join(backend_group_by),
+            "custom_rate_metrics_requests": [
+                {"rate": "count", "numerator": "total"},
+            ],
+        }
+        if start:
+            payload["start_date"] = start
+        if end:
+            payload["end_date"] = end
+        if filters:
+            payload["conversation_filters"] = filters
+
+        data = await self.analytics_report(payload)
+        rows: list[dict[str, Any]] = []
+        for item in data.get("count", []):
+            group_values = _decode_dashboard_group(item.get("group"), len(group_by))
+            group_values = [*group_values, *([None] * len(group_by))][: len(group_by)]
+            rows.append(
+                {
+                    **dict(zip(group_by, group_values, strict=False)),
+                    "count": item.get("numerator", item.get("rate", 0)),
+                }
+            )
+        _sort_analytics_rows(rows, group_by)
+
+        total_rows = len(rows)
+        if limit is not None:
+            rows = rows[:limit]
+
+        return {
+            "columns": [*group_by, "count"],
+            "rows": rows,
+            "row_count": len(rows),
+            "truncated": limit is not None and total_rows > len(rows),
+        }
+
     async def analytics_sql(
         self,
         *,
@@ -633,15 +830,10 @@ class AppliedClient:
         parameters: dict[str, Any] | None = None,
         max_rows: int | None = None,
     ) -> dict:
-        body: dict[str, Any] = {
-            "mode": "sql",
-            "sql": sql,
-        }
-        if parameters:
-            body["parameters"] = parameters
-        if max_rows is not None:
-            body["max_rows"] = max_rows
-        return await self._request("POST", "/v2/agents/analytics/query/", body=body)
+        raise ValueError(
+            "Raw analytics SQL is no longer available through the public API. "
+            "Use applied analytics or applied analytics-report, which call /v2/analytics/."
+        )
 
     async def analytics_metrics(
         self,

{applied_cli-0.5.69 → applied_cli-0.5.71}/applied_cli/flow_helpers.py

@@ -16,6 +16,7 @@ _CANONICAL_EXECUTOR_TYPES: tuple[str, ...] = (
     "code",
     "http_request",
     "loop",
+    "agent_loop",
     "memory",
     "search",
     "recommend",
@@ -38,6 +39,7 @@ _EXECUTOR_UI_LABELS: dict[str, str] = {
     "code": "Code",
     "http_request": "HTTP Request",
     "loop": "Loop",
+    "agent_loop": "Agent Loop",
     "memory": "Memory",
     "search": "Search",
     "recommend": "Recommend",
@@ -62,6 +64,7 @@ _EXECUTOR_ALIASES: dict[str, tuple[str, ...]] = {
         "structured completion",
     ),
     "flow": ("run flow", "run_flow", "subflow"),
+    "agent_loop": ("agent loop", "planner loop", "tool belt", "agentic loop"),
     "end_flow": (
         "end flow return",
         "end flow and return",

{applied_cli-0.5.69 → applied_cli-0.5.71}/applied_cli/tools.py

@@ -660,21 +660,24 @@ async def analytics_query(
     limit: int | None = None,
     output_format: str = "csv",
 ) -> str:
-    """Run a server-side ClickHouse GROUP BY query on conversation data.
+    """Run a server-side GROUP BY count query on conversation data.
 
-    Dimensions: label_id, label_name, sublabel_id, sublabel_name,
-                agent_id, agent_name, resolution, sentiment, score, type, user_id
-    Metrics: count, avg_score, avg_ttr, resolution_rate
+    Dimensions: topic, intent, label_id, label_name, sublabel_id, sublabel_name,
+                agent_id, resolution, sentiment, type, user_id
+    Metrics: count
     Filters: agent_id, label_id, sublabel_id, type, resolution, sentiment, score, user_id
     """
-    data = await client.analytics_query(
-        group_by=group_by,
-        metrics=metrics,
-        filters=filters,
-        start=start,
-        end=end,
-        limit=limit,
-    )
+    try:
+        data = await client.analytics_query(
+            group_by=group_by,
+            metrics=metrics,
+            filters=filters,
+            start=start,
+            end=end,
+            limit=limit,
+        )
+    except ValueError as exc:
+        return _format_argument_error(str(exc))
     rows = data.get("rows", [])
     if not rows:
         return "No data found for the given query."
@@ -695,7 +698,12 @@ async def analytics_sql(
     output_format: str = "csv",
 ) -> str:
     """Run a raw scoped analytics SQL query."""
-    data = await client.analytics_sql(sql=sql, parameters=parameters, max_rows=limit)
+    try:
+        data = await client.analytics_sql(
+            sql=sql, parameters=parameters, max_rows=limit
+        )
+    except ValueError as exc:
+        return _format_argument_error(str(exc))
     rows = data.get("rows", [])
     if not rows:
         return "No data found for the given query."
@@ -2383,6 +2391,39 @@ async def flow_node_create(
             '"position": {"x": 0, "y": 600}}\''
         )
 
+    # Validate agent_loop metadata
+    if canonical_executor_type == "agent_loop":
+        tool_belt = metadata.get("tool_belt")
+        if not tool_belt:
+            return (
+                "❌ Error: agent_loop node requires a non-empty 'tool_belt' in metadata.\n\n"
+                "💡 Required fields:\n"
+                '  - tool_belt: list of {"action_name", "flow_id", "description"} entries\n'
+                "      Each entry maps a planner action name to an operational subflow.\n"
+                "  - model: \"fast\" or \"powerful\" (optional, default \"fast\")\n"
+                "  - content: string - LLM context block (optional; auto-built from\n"
+                "      the conversation trigger when empty and include_trigger_context=true)\n"
+                "  - include_trigger_context: bool (optional, default true)\n"
+                "  - planner_schema: list of SchemaField dicts for extra planner outputs\n"
+                "  - max_steps: int >= 1 (optional, default 10)\n"
+                "  - max_parallel_actions: int >= 1 (optional, default 3)\n\n"
+                "Example:\n"
+                'metadata=\'{"model": "fast", "max_steps": 8, "tool_belt": ['
+                '{"action_name": "lookup_order", "flow_id": "<subflow-uuid>", '
+                '"description": "Fetch an order by number"}], '
+                '"position": {"x": 0, "y": 300}}\''
+            )
+        if not isinstance(tool_belt, list) or not all(
+            isinstance(entry, dict)
+            and entry.get("action_name")
+            and entry.get("flow_id")
+            for entry in tool_belt
+        ):
+            return (
+                "❌ Error: agent_loop 'tool_belt' must be a list of objects, "
+                "each with 'action_name' and 'flow_id'."
+            )
+
     # Validate mutate_ticket metadata
     is_mutate_ticket = canonical_executor_type == "mutate_ticket"
     ticket_missing_name = not metadata or "name" not in metadata
@@ -3766,6 +3807,36 @@ async def executor_list(
             },
             "output_fields": ["results", "count"],
         },
+        {
+            "name": "agent_loop",
+            "ui_label": "Agent Loop",
+            "aliases": executor_aliases("agent_loop"),
+            "description": "Planner-driven loop that dispatches tool-belt subflows until it finishes",
+            "use_case": (
+                "Let an LLM planner iteratively choose which operational "
+                "subflows to call (in parallel where safe) before replying. "
+                "Each tool-belt entry maps an action name to an operational flow; "
+                "the planner emits one or more calls per step and ends with 'finish'."
+            ),
+            "metadata_fields": {
+                "model": "string - 'fast' or 'powerful' (default 'fast')",
+                "content": "string - LLM context block; leave empty to auto-build from the conversation trigger",
+                "include_trigger_context": "bool - auto-assemble trigger context when content is empty (default true)",
+                "tool_belt": (
+                    "array (required) - list of {action_name, flow_id, description} entries; "
+                    "each flow_id must be an operational subflow"
+                ),
+                "planner_schema": "array - SchemaField dicts surfaced on the loop's output and per-step payload",
+                "max_steps": "int >= 1 - hard cap on planner iterations (default 10)",
+                "max_parallel_actions": "int >= 1 - max actions the planner may dispatch per step (default 3)",
+            },
+            "output_fields": [
+                "outcome",
+                "steps_taken",
+                "max_steps_reached",
+                "(plus fields defined by planner_schema)",
+            ],
+        },
         {
             "name": "memory",
             "ui_label": "Memory",

{applied_cli-0.5.69 → applied_cli-0.5.71}/applied_cli.egg-info/PKG-INFO

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

{applied_cli-0.5.69 → applied_cli-0.5.71}/pyproject.toml

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

{applied_cli-0.5.69 → applied_cli-0.5.71}/tests/test_client.py

@@ -170,52 +170,42 @@ async def test_analytics_report_posts_payload(monkeypatch):
 
 
 @pytest.mark.asyncio
-async def test_analytics_sql_posts_payload(monkeypatch):
+async def test_analytics_sql_fails_fast_without_public_endpoint(monkeypatch):
     client = AppliedClient(token="test-token")
-    seen = {}
 
     async def fake_request(method, path, params=None, body=None, shop_id=None):
-        seen["method"] = method
-        seen["path"] = path
-        seen["body"] = body
-        return {"rows": []}
+        raise AssertionError("analytics_sql should not call removed endpoints")
 
     monkeypatch.setattr(client, "_request", fake_request)
 
-    result = await client.analytics_sql(
-        sql="SELECT count() AS total FROM conversation_latest_state",
-        parameters={"resolution": "escalated"},
-        max_rows=25,
-    )
-
-    assert result == {"rows": []}
-    assert seen == {
-        "method": "POST",
-        "path": "/v2/agents/analytics/query/",
-        "body": {
-            "mode": "sql",
-            "sql": "SELECT count() AS total FROM conversation_latest_state",
-            "parameters": {"resolution": "escalated"},
-            "max_rows": 25,
-        },
-    }
+    with pytest.raises(ValueError, match="/v2/analytics/"):
+        await client.analytics_sql(
+            sql="SELECT count() AS total FROM conversation_latest_state",
+            parameters={"resolution": "escalated"},
+            max_rows=25,
+        )
 
 
 @pytest.mark.asyncio
-async def test_analytics_query_builds_legacy_sql(monkeypatch):
+async def test_analytics_query_uses_dashboard_rate_metrics(monkeypatch):
     client = AppliedClient(token="test-token")
     seen = {}
 
-    async def fake_analytics_sql(*, sql, parameters=None, max_rows=None):
-        seen["sql"] = sql
-        seen["parameters"] = parameters
-        seen["max_rows"] = max_rows
+    async def fake_analytics_report(payload):
+        seen["payload"] = payload
         return {
-            "columns": ["resolution", "count"],
-            "rows": [{"resolution": "escalated", "count": 4}],
+            "count": [
+                {
+                    "period": None,
+                    "group": "escalated",
+                    "denominator": 0,
+                    "numerator": 4,
+                    "rate": 4,
+                }
+            ]
         }
 
-    monkeypatch.setattr(client, "analytics_sql", fake_analytics_sql)
+    monkeypatch.setattr(client, "analytics_report", fake_analytics_report)
 
     result = await client.analytics_query(
         group_by=["resolution"],
@@ -229,15 +219,53 @@ async def test_analytics_query_builds_legacy_sql(monkeypatch):
     assert result["rows"] == [{"resolution": "escalated", "count": 4}]
     assert result["dimensions"] == ["resolution"]
     assert result["metrics"] == ["count"]
-    assert "SELECT resolution AS resolution, count() AS count" in seen["sql"]
-    assert "FROM conversation_latest_state" in seen["sql"]
-    assert "agent_id = 'agent-1'" in seen["sql"]
-    assert "score = 2" in seen["sql"]
-    assert "created_at >= '2026-03-01'" in seen["sql"]
-    assert "created_at <= '2026-03-31'" in seen["sql"]
-    assert "LIMIT 100" in seen["sql"]
-    assert seen["parameters"] is None
-    assert seen["max_rows"] == 100
+    assert seen["payload"] == {
+        "view": "dashboard_rate_metrics",
+        "model": "conversation",
+        "group_by": "resolution",
+        "custom_rate_metrics_requests": [{"rate": "count", "numerator": "total"}],
+        "start_date": "2026-03-01",
+        "end_date": "2026-03-31",
+        "conversation_filters": {"agent_id": "agent-1", "score": 2},
+    }
+
+
+@pytest.mark.asyncio
+async def test_analytics_query_uses_automation_aggregates_for_intent_names(monkeypatch):
+    client = AppliedClient(token="test-token")
+    seen = {}
+
+    async def fake_analytics_report(payload):
+        seen["payload"] = payload
+        return {
+            "by_intent": [
+                {"sublabel_name": "Returns", "total": 2},
+                {"sublabel_name": "Returns", "total": 3},
+                {"sublabel_name": "Shipping", "total": 1},
+            ]
+        }
+
+    monkeypatch.setattr(client, "analytics_report", fake_analytics_report)
+
+    result = await client.analytics_query(
+        group_by=["sublabel_name"],
+        metrics=["count"],
+        start="2026-04-27",
+        end="2026-05-01",
+        limit=10,
+    )
+
+    assert result["columns"] == ["sublabel_name", "count"]
+    assert result["rows"] == [
+        {"sublabel_name": "Returns", "count": 5},
+        {"sublabel_name": "Shipping", "count": 1},
+    ]
+    assert seen["payload"] == {
+        "view": "automation_aggregates",
+        "model": "conversation",
+        "start_date": "2026-04-27",
+        "end_date": "2026-05-01",
+    }
 
 
 @pytest.mark.asyncio