applied-cli 0.5.4__tar.gz → 0.5.6__tar.gz

{applied_cli-0.5.4 → applied_cli-0.5.6}/PKG-INFO

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

{applied_cli-0.5.4 → applied_cli-0.5.6}/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.4"
+__version__ = "0.5.5"
 
 __all__ = ["AppliedClient", "tools", "to_csv", "to_json", "__version__"]

{applied_cli-0.5.4 → applied_cli-0.5.6}/applied_cli/client.py

@@ -390,3 +390,111 @@ class AppliedClient:
             params={"type": object_type, "id": object_id},
         )
         return data.get("spans", [])
+
+    # -------------------------------------------------------------------------
+    # Conversational Testing (via streaming /complete endpoint)
+    # -------------------------------------------------------------------------
+
+    async def send_message(
+        self,
+        agent_id: str,
+        message: str,
+        conversation_id: str | None = None,
+        contact_email: str | None = None,
+        contact_name: str | None = None,
+        contact_phone: str | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Send a message to an agent and wait for the response.
+
+        This calls the /complete endpoint (streaming) and consumes the full
+        response. Use this for testing conversational flows.
+
+        Args:
+            agent_id: The agent UUID
+            message: The user message to send
+            conversation_id: Optional existing conversation to continue
+            contact_email: Optional contact email for context
+            contact_name: Optional contact name for context
+            contact_phone: Optional contact phone for context
+            metadata: Optional metadata dict for the conversation
+
+        Returns:
+            Dict with conversation_id, response_text, and status
+        """
+        headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json",
+            "Accept": "text/event-stream",
+        }
+        if self.shop_id:
+            headers["X-Shop-Id"] = self.shop_id
+
+        body: dict[str, Any] = {
+            "transcript": [
+                {
+                    "role": "user",
+                    "content": message,
+                    "text": message,
+                    "format": "markdown",
+                }
+            ],
+        }
+
+        if conversation_id:
+            body["conversation_id"] = conversation_id
+
+        # Build metadata with contact info
+        meta = metadata or {}
+        if contact_email:
+            meta["email"] = contact_email
+        if contact_name:
+            meta["name"] = contact_name
+        if contact_phone:
+            meta["phone"] = contact_phone
+        if meta:
+            body["metadata"] = meta
+
+        url = f"{self.base_url}/v1/agents/{agent_id}/complete/"
+
+        response_text = ""
+        result_conversation_id = conversation_id
+
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            async with client.stream(
+                "POST", url, headers=headers, json=body
+            ) as response:
+                response.raise_for_status()
+
+                async for line in response.aiter_lines():
+                    if not line:
+                        continue
+
+                    # Parse SSE format: "data: {...}"
+                    if line.startswith("data: "):
+                        data_str = line[6:]  # Remove "data: " prefix
+                        if data_str == "[DONE]":
+                            break
+
+                        try:
+                            import json
+
+                            data = json.loads(data_str)
+
+                            # Extract conversation_id from first chunk
+                            if not result_conversation_id:
+                                result_conversation_id = data.get("conversation_id")
+
+                            # Accumulate response content
+                            if "content" in data:
+                                response_text += data["content"]
+
+                        except (json.JSONDecodeError, KeyError):
+                            # Skip malformed chunks
+                            pass
+
+        return {
+            "conversation_id": result_conversation_id,
+            "response": response_text,
+            "status": "success" if response_text else "empty",
+        }

{applied_cli-0.5.4 → applied_cli-0.5.6}/applied_cli/tools.py

@@ -4,6 +4,8 @@ These functions wrap the client methods with formatting logic,
 suitable for both MCP tools and CLI commands.
 """
 
+import json
+
 from applied_cli.client import AppliedClient
 from applied_cli.formatters import select_fields, to_csv, to_json
 
@@ -742,10 +744,50 @@ async def flow_run_get(
                 result += f" - {status_msg}"
             result += "\n"
 
-            # Show executor output for executor_run spans
+            # executor_run: parse output JSON and show fields individually
             if name == "executor_run" and attrs.get("output"):
-                output = str(attrs.get("output", ""))[:500]
-                result += f"   Output: {output}\n"
+                try:
+                    output_data = json.loads(attrs["output"])
+                    for k, v in output_data.items():
+                        if k == "success":
+                            continue
+                        result += f"   output.{k}: {str(v)[:300]}\n"
+                except (json.JSONDecodeError, TypeError):
+                    result += f"   output: {str(attrs['output'])[:500]}\n"
+
+            # completion: show the LLM text output
+            elif name == "completion" and attrs.get("content"):
+                result += f"   completion: {str(attrs['content'])[:500]}\n"
+
+            # structured_completion: show parsed output
+            elif name == "structured_completion" and attrs.get("output"):
+                try:
+                    out = json.loads(attrs["output"])
+                    result += f"   output: {json.dumps(out, indent=None)[:400]}\n"
+                except (json.JSONDecodeError, TypeError):
+                    result += f"   output: {str(attrs['output'])[:400]}\n"
+
+            # branch: show routing decision and comparison breakdown
+            elif name == "branch":
+                selected = attrs.get("selected.path", "")
+                if selected:
+                    path_label = (
+                        "default (no match)"
+                        if selected == "default"
+                        else f"branch {selected}"
+                    )
+                    result += f"   selected path: {path_label}\n"
+                # Show comparison evaluations
+                idx = 1
+                while True:
+                    op = attrs.get(f"comparison.{idx}.operator")
+                    if not op:
+                        break
+                    lhs = attrs.get(f"comparison.{idx}.lhs", "?")
+                    rhs = attrs.get(f"comparison.{idx}.rhs", "?")
+                    res = attrs.get(f"comparison.{idx}.result", "?")
+                    result += f"   comparison {idx}: {lhs} {op} {rhs} => {res}\n"
+                    idx += 1
 
     # Actions
     actions = run.get("actions", [])
@@ -845,6 +887,66 @@ async def conversation_spans(
     return result
 
 
+async def send_message(
+    client: AppliedClient,
+    agent_id: str,
+    message: str,
+    conversation_id: str | None = None,
+    contact_email: str | None = None,
+    contact_name: str | None = None,
+    contact_phone: str | None = None,
+) -> str:
+    """
+    Send a message to an agent and get the response.
+
+    Use this to test conversational flows. After sending, you can query
+    the conversation messages with conversation_get for full details.
+
+    Args:
+        client: Authenticated AppliedClient
+        agent_id: The agent UUID to send the message to
+        message: The user message to send
+        conversation_id: Optional - continue an existing conversation
+        contact_email: Optional contact email (for flows that need it)
+        contact_name: Optional contact name
+        contact_phone: Optional contact phone
+
+    Returns:
+        Conversation ID, response preview, and status
+    """
+    try:
+        result = await client.send_message(
+            agent_id=agent_id,
+            message=message,
+            conversation_id=conversation_id,
+            contact_email=contact_email,
+            contact_name=contact_name,
+            contact_phone=contact_phone,
+        )
+
+        output = "# Message Sent\n"
+        output += f"conversation_id: {result.get('conversation_id')}\n"
+        output += f"status: {result.get('status')}\n"
+
+        response = result.get("response", "")
+        if response:
+            # Truncate long responses for preview
+            preview = response[:500] + "..." if len(response) > 500 else response
+            output += f"\n## Response Preview\n{preview}\n"
+
+        output += "\n## Next Steps\n"
+        output += (
+            "- Use `conversation_get` with the conversation_id to see full messages\n"
+        )
+        output += "- Use `flow_run_list` with conversation_id to see flow runs\n"
+        output += "- Use `conversation_spans` for detailed execution trace\n"
+
+        return output
+
+    except Exception as e:
+        return f"Error sending message: {e}"
+
+
 async def executor_list(
     client: AppliedClient,
     output_format: str = "csv",

{applied_cli-0.5.4 → applied_cli-0.5.6}/applied_cli.egg-info/PKG-INFO

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

{applied_cli-0.5.4 → applied_cli-0.5.6}/pyproject.toml

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