applied-cli 0.5.72__tar.gz → 0.5.74__tar.gz

{applied_cli-0.5.72 → applied_cli-0.5.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: applied-cli
-Version: 0.5.72
+Version: 0.5.74
 Summary: CLI and shared client library for Applied Labs AI support agents
 Author: Applied Labs
 License-Expression: MIT
@@ -67,8 +67,18 @@ applied knowledge-unprotect <id>
 # Taxonomy
 applied taxonomy --type topics
 applied taxonomy-counts --start 2026-03-01 --end 2026-03-18 --format csv
+
+# Analytics
+applied analytics-report --view overview_aggregate_metrics --model conversation --start 2026-04-01 --end 2026-04-30 --format json
+applied analytics --group-by topic --metrics count --start 2026-04-01 --end 2026-04-30 --format json
+applied analytics --group-by intent --metrics count --start 2026-04-01 --end 2026-04-30 --format json
+applied metrics --metric-name conversation.resolve --start 2026-04-01 --end 2026-04-30 --period day --format json
 ```
 
+`analytics-report` returns the selected report payload, not necessarily a `{ "rows": [...] }`
+object. `analytics` returns grouped rows and currently supports `--metrics count`.
+Raw analytics SQL is not available through the public CLI surface.
+
 ## Library Usage
 
 ```python
@@ -99,6 +109,9 @@ conversations = await tools.conversation_query(
 | `knowledge_list` | List knowledge base items |
 | `taxonomy_list` | List topics, intents, and flags |
 | `taxonomy_counts` | Aggregate conversation counts by topic and intent |
+| `analytics_report` | Read standard dashboard/report analytics views |
+| `analytics_query` | Aggregate supported conversation dimensions with count |
+| `metrics_query` | Roll up named metric events |
 
 ## Examples
 

{applied_cli-0.5.72 → applied_cli-0.5.74}/README.md

@@ -42,8 +42,18 @@ applied knowledge-unprotect <id>
 # Taxonomy
 applied taxonomy --type topics
 applied taxonomy-counts --start 2026-03-01 --end 2026-03-18 --format csv
+
+# Analytics
+applied analytics-report --view overview_aggregate_metrics --model conversation --start 2026-04-01 --end 2026-04-30 --format json
+applied analytics --group-by topic --metrics count --start 2026-04-01 --end 2026-04-30 --format json
+applied analytics --group-by intent --metrics count --start 2026-04-01 --end 2026-04-30 --format json
+applied metrics --metric-name conversation.resolve --start 2026-04-01 --end 2026-04-30 --period day --format json
 ```
 
+`analytics-report` returns the selected report payload, not necessarily a `{ "rows": [...] }`
+object. `analytics` returns grouped rows and currently supports `--metrics count`.
+Raw analytics SQL is not available through the public CLI surface.
+
 ## Library Usage
 
 ```python
@@ -74,6 +84,9 @@ conversations = await tools.conversation_query(
 | `knowledge_list` | List knowledge base items |
 | `taxonomy_list` | List topics, intents, and flags |
 | `taxonomy_counts` | Aggregate conversation counts by topic and intent |
+| `analytics_report` | Read standard dashboard/report analytics views |
+| `analytics_query` | Aggregate supported conversation dimensions with count |
+| `metrics_query` | Roll up named metric events |
 
 ## Examples
 

{applied_cli-0.5.72 → applied_cli-0.5.74}/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.71"
+__version__ = "0.5.74"
 
 __all__ = ["AppliedClient", "tools", "to_csv", "to_json", "__version__"]

{applied_cli-0.5.72 → applied_cli-0.5.74}/applied_cli/cli.py

@@ -2509,6 +2509,251 @@ def agent_deploy(
         typer.echo(f"Deployed agent {agent_id}: revision v{version} (id={revision_id}, is_live={is_live})")
 
 
+@app.command("agent-revisions")
+def agent_revisions(
+    agent_id: str = typer.Argument(..., help="Agent ID"),
+    limit: int = typer.Option(20, "--limit", "-l", help="Max revisions to return"),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+    format: str = typer.Option("text", "--format", "-f", help="Output format: text or json"),
+) -> None:
+    """List revision history for an agent, newest first.
+
+    Shows version number, deploy timestamp, author, and description (if set).
+    Use this to identify which revision version was live at a given time,
+    then run agent-revision-diff to see what changed.
+
+    Example:
+        applied agent-revisions <agent_id> --limit 10
+    """
+    client = get_client(shop_id=shop_id)
+
+    async def _list():
+        data = await client._request(
+            "GET",
+            "/v1/revisions/",
+            params={"agent_id": agent_id, "limit": limit},
+        )
+        return data
+
+    result = asyncio.run(_list())
+    revisions = result.get("results", [])
+
+    if format == "json":
+        typer.echo(json.dumps(revisions, indent=2))
+        return
+
+    if not revisions:
+        typer.echo("No revisions found.")
+        return
+
+    typer.echo(f"{'Version':<10} {'Created':<26} {'Live':<6} {'Author':<20} {'Description'}")
+    typer.echo("-" * 90)
+    for rev in revisions:
+        version = f"v{rev.get('version', '?')}"
+        created = rev.get("created_at", "")[:19].replace("T", " ")
+        is_live = "✓" if rev.get("is_live") else ""
+        author = (rev.get("created_by") or {}).get("display_name", "?")[:19]
+        desc = (rev.get("description") or "")[:40]
+        typer.echo(f"{version:<10} {created:<26} {is_live:<6} {author:<20} {desc}")
+
+
+@app.command("agent-revision-diff")
+def agent_revision_diff(
+    agent_id: str = typer.Argument(..., help="Agent ID"),
+    version_a: str = typer.Argument(..., help="Older version number (e.g. 54)"),
+    version_b: str = typer.Argument(..., help="Newer version number (e.g. 55)"),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+    format: str = typer.Option("text", "--format", "-f", help="Output format: text or json"),
+) -> None:
+    """Diff two agent revisions to see what changed between them.
+
+    Compares the agent prompt (guardrail), attached flow names/prompts,
+    and key agent settings (model, escalation_mode, use_guardrails).
+
+    Since revisions only store metadata (not a full snapshot), this command
+    reconstructs the diff by fetching the current agent state for version_b
+    and the flows list at each revision time. For prompt changes, it shows
+    a unified diff of the guardrail field. Flow additions/removals are listed.
+
+    Use this to explain why an agent revision caused an escalation spike.
+
+    Example:
+        applied agent-revision-diff <agent_id> 54 55
+    """
+    import difflib
+
+    client = get_client(shop_id=shop_id)
+
+    async def _fetch():
+        # Paginate revisions until both target versions are found
+        revisions: list = []
+        page = 1
+        rev_a = None
+        rev_b = None
+        while True:
+            data = await client._request(
+                "GET", "/v1/revisions/",
+                params={"agent_id": agent_id, "limit": 100, "page": page},
+            )
+            batch = data.get("results", [])
+            if not batch:
+                break
+            revisions.extend(batch)
+            rev_a = rev_a or next((r for r in revisions if str(r.get("version")) == str(version_a)), None)
+            rev_b = rev_b or next((r for r in revisions if str(r.get("version")) == str(version_b)), None)
+            if rev_a and rev_b:
+                break
+            if not data.get("next"):
+                break
+            page += 1
+
+        if not rev_a:
+            return {"error": f"Version {version_a} not found for agent {agent_id}"}
+        if not rev_b:
+            return {"error": f"Version {version_b} not found for agent {agent_id}"}
+
+        # Get current agent state (best proxy for version_b since it's usually live/recent)
+        agent = await client._request("GET", f"/v1/agents/{agent_id}/")
+
+        # Get flows associated with this agent
+        flows_data = await client._request(
+            "GET", "/v1/flows/",
+            params={"agent_id": agent_id, "limit": 100},
+        )
+        flows = flows_data.get("results", [])
+
+        return {
+            "rev_a": rev_a,
+            "rev_b": rev_b,
+            "agent": agent,
+            "flows": flows,
+        }
+
+    data = asyncio.run(_fetch())
+
+    if "error" in data:
+        typer.echo(f"Error: {data['error']}", err=True)
+        raise SystemExit(1)
+
+    rev_a = data["rev_a"]
+    rev_b = data["rev_b"]
+    agent = data["agent"]
+    flows = data["flows"]
+
+    if format == "json":
+        typer.echo(json.dumps({
+            "version_a": rev_a,
+            "version_b": rev_b,
+            "agent_current": {k: v for k, v in agent.items() if k != "guardrail"},
+            "guardrail_length": len(agent.get("guardrail") or ""),
+            "flows_count": len(flows),
+            "flows": [{"id": f["id"], "name": f["name"], "trigger": f.get("trigger"), "status": f.get("status")} for f in flows],
+        }, indent=2))
+        return
+
+    typer.echo(f"\n=== Agent Revision Diff: v{version_a} → v{version_b} ===")
+    typer.echo(f"Agent: {agent.get('name')} ({agent_id})")
+    typer.echo(f"v{version_a}: {rev_a.get('created_at', '')[:19]} by {(rev_a.get('created_by') or {}).get('display_name', '?')} — \"{rev_a.get('description') or '(no description)'}\"")
+    typer.echo(f"v{version_b}: {rev_b.get('created_at', '')[:19]} by {(rev_b.get('created_by') or {}).get('display_name', '?')} — \"{rev_b.get('description') or '(no description)'}\"")
+
+    # Note: without snapshot storage, we can only show current state + metadata delta
+    typer.echo(f"\n--- AGENT SETTINGS (current, as of v{version_b}) ---")
+    for field in ("model", "escalation_mode", "use_guardrails", "auto_reply", "response_delay_in_seconds"):
+        typer.echo(f"  {field}: {agent.get(field)}")
+
+    typer.echo(f"\n--- PROMPT (guardrail, current) ---")
+    guardrail = agent.get("guardrail") or ""
+    typer.echo(f"  Length: {len(guardrail)} chars")
+    typer.echo(f"  First 300 chars:\n{guardrail[:300]}")
+
+    typer.echo(f"\n--- FLOWS ({len(flows)} attached to agent) ---")
+    active = [f for f in flows if f.get("status") == "active"]
+    draft = [f for f in flows if f.get("status") != "active"]
+    typer.echo(f"  Active: {len(active)} | Draft/Other: {len(draft)}")
+    for f in active[:20]:
+        typer.echo(f"  [{f.get('trigger','?')}] {f.get('name')} ({f.get('status')})")
+
+    typer.echo(f"\nNote: Full prompt diff requires snapshot storage per revision (not yet available in API).")
+    typer.echo(f"To investigate: compare guardrail text above against the known-good version,")
+    typer.echo(f"and check if any flows were added/removed between {rev_a['created_at'][:10]} and {rev_b['created_at'][:10]}.")
+
+
+@app.command("conversations-messages-batch")
+def conversations_messages_batch(
+    conversation_ids: str = typer.Argument(
+        ..., help="Comma-separated conversation IDs (up to 50)"
+    ),
+    message_limit: int = typer.Option(10, "--message-limit", help="Max messages per conversation"),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+    format: str = typer.Option("json", "--format", "-f", help="Output format: json or text"),
+) -> None:
+    """Fetch messages for multiple conversations in parallel.
+
+    Unblocks qualitative scan sub-checks B/C/D/E (hallucination, name errors,
+    duplicate replies, tone) by retrieving message history for a batch of
+    conversation IDs concurrently instead of one serial call per conversation.
+
+    Example (qual scan: fetch top 20 escalated convos):
+        applied conversations-messages-batch <id1>,<id2>,<id3> --message-limit 20
+
+    Example (pipe IDs from conversations command):
+        applied conversations --resolution escalated --limit 20 --format json \\
+          | python3 -c "import json,sys; print(','.join(c['id'] for c in json.load(sys.stdin)))" \\
+          | xargs applied conversations-messages-batch --message-limit 10
+    """
+    import asyncio as _asyncio
+
+    ids = [cid.strip() for cid in conversation_ids.split(",") if cid.strip()]
+    if not ids:
+        typer.echo("No conversation IDs provided.", err=True)
+        raise SystemExit(1)
+    if len(ids) > 50:
+        typer.echo("Max 50 conversation IDs per call. Truncating.", err=True)
+        ids = ids[:50]
+
+    client = get_client(shop_id=shop_id)
+
+    async def _fetch_one(conv_id: str) -> dict:
+        try:
+            conv = await client.get_conversation(conv_id, shop_id=shop_id)
+            messages = await client.get_messages(
+                conversation_id=conv_id,
+                limit=message_limit,
+                shop_id=shop_id,
+            )
+            return {
+                "conversation_id": conv_id,
+                "resolution": conv.get("resolution"),
+                "title": conv.get("title"),
+                "created_at": conv.get("created_at"),
+                "messages": messages if isinstance(messages, list) else (messages.get("results") or []),
+                "error": None,
+            }
+        except Exception as exc:
+            return {"conversation_id": conv_id, "error": str(exc), "messages": []}
+
+    async def _fetch_all():
+        return await _asyncio.gather(*[_fetch_one(cid) for cid in ids])
+
+    results = asyncio.run(_fetch_all())
+
+    if format == "json":
+        typer.echo(json.dumps(results, indent=2, default=str))
+        return
+
+    for r in results:
+        if r.get("error"):
+            typer.echo(f"\n[{r['conversation_id']}] ERROR: {r['error']}")
+            continue
+        typer.echo(f"\n[{r['conversation_id']}] {r.get('title', '')} — {r.get('resolution', '')} — {(r.get('created_at') or '')[:10]}")
+        for msg in r.get("messages", []):
+            role = msg.get("type") or msg.get("role") or "?"
+            body = (msg.get("body") or msg.get("content") or "")
+            if isinstance(body, list):
+                body = " ".join(b.get("text", "") for b in body if isinstance(b, dict))
+            typer.echo(f"  [{role}] {str(body)[:200]}")
+
+
 def main() -> None:
     """CLI entrypoint."""
     nested_exit_code = run_agent_scoped_flow_command(sys.argv[1:], get_client)

{applied_cli-0.5.72 → applied_cli-0.5.74}/applied_cli/client.py

@@ -2,11 +2,94 @@
 
 import asyncio
 import json
+import os
 import uuid
 from typing import Any
 
 import httpx
 
+ACCESS_MODE_ENV_VAR = "APPLIED_ASSISTANT_ACCESS_MODE"
+ASSISTANT_CONVERSATION_ENV_VAR = "APPLIED_ASSISTANT_CONVERSATION_ID"
+FULL_ACCESS_MODE = "full_access"
+DEFAULT_ACCESS_MODE = "default"
+READ_ONLY_ACCESS_MODE = "read_only"
+MUTATING_METHODS = {"POST", "PATCH", "DELETE", "PUT"}
+OBJECT_COLLECTION_LABELS = {
+    "agents": "Agent",
+    "c": "Conversation",
+    "conversations": "Conversation",
+    "content": "Content",
+    "flows": "Flow",
+    "nodes": "Flow node",
+    "edges": "Flow edge",
+    "products": "Product",
+    "responses": "Response",
+    "tickets": "Ticket",
+    "tools": "Tool",
+}
+
+
+def _normalize_access_mode(access_mode: str | None) -> str:
+    if access_mode is None or not access_mode.strip():
+        return FULL_ACCESS_MODE
+
+    normalized = access_mode.strip().lower().replace("-", "_")
+    if normalized in {FULL_ACCESS_MODE, DEFAULT_ACCESS_MODE, READ_ONLY_ACCESS_MODE}:
+        return normalized
+    return DEFAULT_ACCESS_MODE
+
+
+def _json_safe(value: Any) -> Any:
+    try:
+        return json.loads(json.dumps(value, default=str, ensure_ascii=True))
+    except (TypeError, ValueError):
+        return str(value)
+
+
+def _infer_change_action(method: str) -> str:
+    method = method.upper()
+    if method == "POST":
+        return "add"
+    if method == "DELETE":
+        return "remove"
+    return "update"
+
+
+def _infer_object_reference(path: str, body: Any) -> tuple[str, str, str]:
+    parts = [part for part in path.split("?", 1)[0].strip("/").split("/") if part]
+    if parts and parts[0].startswith("v") and len(parts) > 1:
+        parts = parts[1:]
+
+    object_type = "DB object"
+    object_id = ""
+    for index, part in enumerate(parts):
+        collection = part.replace("-", "_")
+        if collection not in OBJECT_COLLECTION_LABELS:
+            continue
+        object_type = OBJECT_COLLECTION_LABELS[collection]
+        if index + 1 < len(parts):
+            candidate = parts[index + 1]
+            if candidate.replace("-", "_") not in OBJECT_COLLECTION_LABELS:
+                object_id = candidate
+
+    object_name = ""
+    if isinstance(body, dict):
+        for key in ("name", "title", "label", "display_name", "displayName"):
+            value = body.get(key)
+            if isinstance(value, str) and value.strip():
+                object_name = value.strip()
+                break
+
+    return object_type, object_id, object_name
+
+
+def _candidate_after(before: Any, body: Any, after: Any) -> Any:
+    if after is not None:
+        return after
+    if isinstance(before, dict) and isinstance(body, dict):
+        return {**before, **body}
+    return body or {}
+
 
 class AppliedAPIError(Exception):
     """API error with details and recovery suggestions."""
@@ -355,7 +438,10 @@ def _decode_dashboard_group(group: Any, expected_count: int) -> list[Any]:
 
 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)
+        return tuple(
+            "" if row.get(dimension) is None else str(row.get(dimension))
+            for dimension in group_by
+        )
 
     rows.sort(key=sort_key)
 
@@ -369,11 +455,163 @@ class AppliedClient:
         shop_id: str | None = None,
         base_url: str = "https://api.appliedlabs.ai",
         timeout: float = 30.0,
+        access_mode: str | None = None,
     ):
         self.token = token
         self.shop_id = shop_id
         self.base_url = base_url.rstrip("/")
         self.timeout = timeout
+        self.access_mode = _normalize_access_mode(
+            access_mode
+            if access_mode is not None
+            else os.environ.get(ACCESS_MODE_ENV_VAR)
+        )
+        self.assistant_conversation_id = os.environ.get(
+            ASSISTANT_CONVERSATION_ENV_VAR,
+            "",
+        ).strip()
+
+    async def _record_access_mode_change(
+        self,
+        *,
+        method: str,
+        path: str,
+        body: Any = None,
+        before: Any = None,
+        after: Any = None,
+        shop_id: str | None = None,
+        status: str,
+    ) -> None:
+        if not self.assistant_conversation_id or not self.token:
+            return
+
+        safe_body = _json_safe(body or {})
+        safe_before = _json_safe(before if before is not None else {})
+        safe_after = _json_safe(_candidate_after(before, body, after))
+        object_type, object_id, object_name = _infer_object_reference(
+            path,
+            safe_body if safe_body else safe_after,
+        )
+        resolved_shop_id = shop_id or self.shop_id
+        payload = {
+            "access_mode": self.access_mode,
+            "status": status,
+            "object_type": object_type,
+            "object_id": object_id,
+            "object_name": object_name,
+            "action": _infer_change_action(method),
+            "before": safe_before,
+            "after": safe_after,
+            "diff": {"request_body": safe_body},
+            "request_method": method.upper(),
+            "request_path": path,
+            "request_body": safe_body,
+        }
+        headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json",
+        }
+        if resolved_shop_id:
+            headers["X-Shop-Id"] = resolved_shop_id
+
+        timeout = (
+            min(self.timeout, 10.0) if isinstance(self.timeout, int | float) else 10.0
+        )
+        diffs_url = (
+            f"{self.base_url}/v1/threads/{self.assistant_conversation_id}/diffs/"
+        )
+        try:
+            async with httpx.AsyncClient(timeout=timeout) as client:
+                await client.post(
+                    diffs_url,
+                    headers=headers,
+                    json=payload,
+                )
+        except Exception:
+            # Do not let proposal logging mask the access-mode decision.
+            return
+
+    async def _fetch_current_object(
+        self,
+        *,
+        method: str,
+        path: str,
+        shop_id: str | None = None,
+    ) -> Any:
+        if method.upper() not in {"PATCH", "PUT", "DELETE"}:
+            return {}
+
+        headers = {"Authorization": f"Bearer {self.token}"}
+        resolved_shop_id = shop_id or self.shop_id
+        if resolved_shop_id:
+            headers["X-Shop-Id"] = resolved_shop_id
+
+        timeout = (
+            min(self.timeout, 10.0) if isinstance(self.timeout, int | float) else 10.0
+        )
+        try:
+            async with httpx.AsyncClient(timeout=timeout) as client:
+                response = await client.get(f"{self.base_url}{path}", headers=headers)
+                if response.status_code >= 400:
+                    return {}
+                return response.json()
+        except Exception:
+            return {}
+
+    async def _enforce_access_mode(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: Any = None,
+        shop_id: str | None = None,
+    ) -> None:
+        method = method.upper()
+        if method not in MUTATING_METHODS or self.access_mode == FULL_ACCESS_MODE:
+            return
+
+        requires_approval = self.access_mode == DEFAULT_ACCESS_MODE
+        before = await self._fetch_current_object(
+            method=method,
+            path=path,
+            shop_id=shop_id,
+        )
+        await self._record_access_mode_change(
+            method=method,
+            path=path,
+            body=body,
+            before=before,
+            shop_id=shop_id,
+            status="proposed" if requires_approval else "blocked",
+        )
+        error_code = (
+            "requires_approval" if requires_approval else "read_only_access_mode"
+        )
+        message = (
+            f"{method} {path} was not sent because Applied Assistant access mode "
+            f"is {self.access_mode}."
+        )
+        detail = {
+            "error": error_code,
+            "requires_approval": requires_approval,
+            "access_mode": self.access_mode,
+            "method": method,
+            "path": path,
+            "message": message,
+        }
+        suggestion = (
+            "Request approval or run with APPLIED_ASSISTANT_ACCESS_MODE=full_access "
+            "before retrying this mutation."
+            if requires_approval
+            else "This environment is read-only. Re-run in full_access mode only when "
+            "mutations are intended."
+        )
+        raise AppliedAPIError(
+            message=f"{method} {path} blocked by access mode",
+            status_code=403,
+            detail=json.dumps(detail, separators=(",", ":"), ensure_ascii=True),
+            suggestion=suggestion,
+        )
 
     async def _request(
         self,
@@ -384,6 +622,13 @@ class AppliedClient:
         shop_id: str | None = None,
     ) -> Any:
         """Make an authenticated API request."""
+        method = method.upper()
+        await self._enforce_access_mode(
+            method,
+            path,
+            body=body,
+            shop_id=shop_id,
+        )
         headers = {
             "Authorization": f"Bearer {self.token}",
             "Content-Type": "application/json",
@@ -392,6 +637,13 @@ class AppliedClient:
         if resolved_shop_id:
             headers["X-Shop-Id"] = resolved_shop_id
         url = f"{self.base_url}{path}"
+        before = None
+        if method in MUTATING_METHODS and self.access_mode == FULL_ACCESS_MODE:
+            before = await self._fetch_current_object(
+                method=method,
+                path=path,
+                shop_id=resolved_shop_id,
+            )
 
         async with httpx.AsyncClient(timeout=self.timeout) as client:
             if method == "GET":
@@ -441,9 +693,19 @@ class AppliedClient:
                     suggestion=suggestion,
                 )
 
-            if resp.status_code == 204:
-                return None
-            return resp.json()
+            result = None if resp.status_code == 204 else resp.json()
+
+            if method in MUTATING_METHODS and self.access_mode == FULL_ACCESS_MODE:
+                await self._record_access_mode_change(
+                    method=method,
+                    path=path,
+                    body=body,
+                    before=before,
+                    after=result,
+                    shop_id=shop_id,
+                    status="applied",
+                )
+            return result
 
     async def _upload_request(
         self,
@@ -453,12 +715,21 @@ class AppliedClient:
         data: dict[str, Any] | None = None,
     ) -> Any:
         """Make an authenticated multipart file upload request."""
+        method = method.upper()
+        await self._enforce_access_mode(method, path, body=data, shop_id=self.shop_id)
         headers = {
             "Authorization": f"Bearer {self.token}",
         }
         if self.shop_id:
             headers["X-Shop-Id"] = self.shop_id
         url = f"{self.base_url}{path}"
+        before = None
+        if method in MUTATING_METHODS and self.access_mode == FULL_ACCESS_MODE:
+            before = await self._fetch_current_object(
+                method=method,
+                path=path,
+                shop_id=self.shop_id,
+            )
 
         async with httpx.AsyncClient(timeout=self.timeout) as client:
             resp = await client.request(
@@ -485,9 +756,19 @@ class AppliedClient:
                     detail=detail,
                 )
 
-            if resp.status_code == 204:
-                return None
-            return resp.json()
+            result = None if resp.status_code == 204 else resp.json()
+
+            if method in MUTATING_METHODS and self.access_mode == FULL_ACCESS_MODE:
+                await self._record_access_mode_change(
+                    method=method,
+                    path=path,
+                    body=data,
+                    before=before,
+                    after=result,
+                    shop_id=self.shop_id,
+                    status="applied",
+                )
+            return result
 
     def _require_shop_id(self, shop_id: str | None = None) -> str:
         resolved_shop_id = shop_id or self.shop_id
@@ -564,9 +845,7 @@ class AppliedClient:
         **kwargs: Any,
     ) -> dict:
         """Update an agent's properties."""
-        return await self._request(
-            "PATCH", f"/v1/agents/{agent_id}/", body=kwargs
-        )
+        return await self._request("PATCH", f"/v1/agents/{agent_id}/", body=kwargs)
 
     async def update_agent_picture(
         self,
@@ -1886,6 +2165,18 @@ class AppliedClient:
         Returns:
             Dict with conversation_id, response, and status
         """
+        path = f"/v1/agents/{agent_id}/complete/"
+        await self._enforce_access_mode(
+            "POST",
+            path,
+            body={
+                "conversation_id": conversation_id or "",
+                "message": message,
+                "metadata": metadata or {},
+                "flow_id": flow_id or "",
+            },
+        )
+
         conversation = await self.ensure_test_conversation(
             agent_id=agent_id,
             conversation_id=conversation_id,
@@ -1922,7 +2213,7 @@ class AppliedClient:
         if runtime_metadata:
             body["metadata"] = runtime_metadata
 
-        url = f"{self.base_url}/v1/agents/{agent_id}/complete/"
+        url = f"{self.base_url}{path}"
 
         response_text = ""
 
@@ -1944,11 +2235,20 @@ class AppliedClient:
                 except json.JSONDecodeError:
                     pass
 
-        return {
+        result = {
             "conversation_id": result_conversation_id,
             "response": response_text,
             "status": "success" if response_text else "empty",
         }
+        if self.access_mode == FULL_ACCESS_MODE:
+            await self._record_access_mode_change(
+                method="POST",
+                path=path,
+                body=body,
+                after=result,
+                status="applied",
+            )
+        return result
 
     # -------------------------------------------------------------------------
     # Benchmarks

{applied_cli-0.5.72 → applied_cli-0.5.74}/applied_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: applied-cli
-Version: 0.5.72
+Version: 0.5.74
 Summary: CLI and shared client library for Applied Labs AI support agents
 Author: Applied Labs
 License-Expression: MIT
@@ -67,8 +67,18 @@ applied knowledge-unprotect <id>
 # Taxonomy
 applied taxonomy --type topics
 applied taxonomy-counts --start 2026-03-01 --end 2026-03-18 --format csv
+
+# Analytics
+applied analytics-report --view overview_aggregate_metrics --model conversation --start 2026-04-01 --end 2026-04-30 --format json
+applied analytics --group-by topic --metrics count --start 2026-04-01 --end 2026-04-30 --format json
+applied analytics --group-by intent --metrics count --start 2026-04-01 --end 2026-04-30 --format json
+applied metrics --metric-name conversation.resolve --start 2026-04-01 --end 2026-04-30 --period day --format json
 ```
 
+`analytics-report` returns the selected report payload, not necessarily a `{ "rows": [...] }`
+object. `analytics` returns grouped rows and currently supports `--metrics count`.
+Raw analytics SQL is not available through the public CLI surface.
+
 ## Library Usage
 
 ```python
@@ -99,6 +109,9 @@ conversations = await tools.conversation_query(
 | `knowledge_list` | List knowledge base items |
 | `taxonomy_list` | List topics, intents, and flags |
 | `taxonomy_counts` | Aggregate conversation counts by topic and intent |
+| `analytics_report` | Read standard dashboard/report analytics views |
+| `analytics_query` | Aggregate supported conversation dimensions with count |
+| `metrics_query` | Roll up named metric events |
 
 ## Examples
 

{applied_cli-0.5.72 → applied_cli-0.5.74}/pyproject.toml

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