applied-cli 0.5.54__tar.gz → 0.5.56__tar.gz

{applied_cli-0.5.54 → applied_cli-0.5.56}/PKG-INFO

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

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

{applied_cli-0.5.54 → applied_cli-0.5.56}/applied_cli/cli.py

@@ -1853,6 +1853,291 @@ def connector_types(
     typer.echo(result)
 
 
+@app.command("agent-update")
+def agent_update(
+    id: str = typer.Argument(..., help="Agent ID"),
+    name: str = typer.Option(None, "--name", help="Agent name"),
+    prompt: str = typer.Option(None, "--prompt", help="Guidance/guardrails text"),
+    model: str = typer.Option(None, "--model", help="Model name"),
+    modality: str = typer.Option(
+        None, "--modality", help="Modality: Chat, Email, Call, SMS, All"
+    ),
+    agent_type: str = typer.Option(
+        None, "--type", help="Type: Customer Support, Generic, etc."
+    ),
+    escalation_mode: str = typer.Option(
+        None,
+        "--escalation-mode",
+        help="Escalation mode: default, email, sms, email_non_opening_hours, ticketing_integration",
+    ),
+    auto_reply: bool = typer.Option(None, "--auto-reply", help="Enable auto-reply"),
+    metadata: str = typer.Option(
+        None, "--metadata", help="JSON metadata to set on the agent"
+    ),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Update an agent."""
+    metadata_dict = _parse_json_option(metadata, option_name="--metadata")
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.agent_update(
+            client,
+            id,
+            name=name,
+            prompt=prompt,
+            model=model,
+            modality=modality,
+            agent_type=agent_type,
+            escalation_mode=escalation_mode,
+            auto_reply=auto_reply,
+            metadata=metadata_dict,
+        )
+    )
+    typer.echo(result)
+
+
+@app.command("knowledge-create")
+def knowledge_create(
+    kb_type: str = typer.Option(
+        ..., "--type", "-t", help="Type: qa, exact, escalate, context, greeting, signature"
+    ),
+    question: str = typer.Option(..., "--question", "-q", help="Trigger text / question"),
+    answer: str = typer.Option(..., "--answer", "-a", help="Response text / answer"),
+    guardrail: str = typer.Option("", "--guardrail", help="Guardrail instructions"),
+    active: bool = typer.Option(True, "--active/--inactive", help="Whether the item is active"),
+    agent_ids: str = typer.Option(
+        None, "--agent-ids", help="Comma-separated agent UUIDs (empty = shop-wide)"
+    ),
+    label_id: str = typer.Option(None, "--label-id", help="Topic label UUID"),
+    flow_id: str = typer.Option(None, "--flow-id", help="Flow UUID to associate with"),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Create a knowledge base item."""
+    parsed_agent_ids = _parse_csv_option(agent_ids)
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.knowledge_create(
+            client,
+            kb_type=kb_type,
+            question=question,
+            answer=answer,
+            guardrail=guardrail,
+            active=active,
+            agent_ids=parsed_agent_ids,
+            label_id=label_id,
+            flow_id=flow_id,
+        )
+    )
+    typer.echo(result)
+
+
+@app.command("knowledge-update")
+def knowledge_update(
+    id: str = typer.Argument(..., help="Knowledge item ID"),
+    question: str = typer.Option(None, "--question", "-q", help="Trigger text / question"),
+    answer: str = typer.Option(None, "--answer", "-a", help="Response text / answer"),
+    guardrail: str = typer.Option(None, "--guardrail", help="Guardrail instructions"),
+    active: bool = typer.Option(None, "--active/--inactive", help="Whether the item is active"),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Update a knowledge base item."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.knowledge_update(
+            client,
+            id,
+            question=question,
+            answer=answer,
+            guardrail=guardrail,
+            active=active,
+        )
+    )
+    typer.echo(result)
+
+
+@app.command("product-create")
+def product_create(
+    title: str = typer.Option(..., "--title", help="Product title"),
+    description: str = typer.Option("", "--description", help="Product description"),
+    url: str = typer.Option("", "--url", help="Product page URL"),
+    images: str = typer.Option(None, "--images", help="Comma-separated image URLs"),
+    price: str = typer.Option(None, "--price", help="Price (e.g. '29.99')"),
+    compare_at_price: str = typer.Option(None, "--compare-at-price", help="Compare-at price"),
+    currency: str = typer.Option("USD", "--currency", help="Currency code"),
+    rating: float = typer.Option(None, "--rating", help="Average rating"),
+    review_count: int = typer.Option(None, "--review-count", help="Number of reviews"),
+    status: str = typer.Option("Active", "--status", help="Status: Active, Draft, Pending"),
+    auto_generate_kb: bool = typer.Option(
+        True, "--auto-generate-kb/--no-auto-generate-kb", help="Auto-generate Q&A"
+    ),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Create a product."""
+    parsed_images = _parse_csv_option(images)
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.product_create(
+            client,
+            title=title,
+            description=description,
+            url=url,
+            images=parsed_images,
+            price=price,
+            compare_at_price=compare_at_price,
+            currency=currency,
+            rating=rating,
+            review_count=review_count,
+            status=status,
+            auto_generate_kb=auto_generate_kb,
+        )
+    )
+    typer.echo(result)
+
+
+@app.command("taxonomy-create")
+def taxonomy_create(
+    name: str = typer.Option(..., "--name", "-n", help="Topic or intent name"),
+    parent_id: str = typer.Option(
+        None, "--parent-id", help="Parent topic UUID (if set, creates an intent)"
+    ),
+    color: str = typer.Option(None, "--color", help="Color"),
+    description: str = typer.Option(None, "--description", help="Description"),
+    comments: str = typer.Option(None, "--comments", help="Example queries (3 per line)"),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Create a topic or intent."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.taxonomy_create(
+            client,
+            name=name,
+            parent_id=parent_id,
+            color=color,
+            description=description,
+            comments=comments,
+        )
+    )
+    typer.echo(result)
+
+
+@app.command("taxonomy-update")
+def taxonomy_update(
+    id: str = typer.Argument(..., help="Topic or intent ID"),
+    name: str = typer.Option(None, "--name", "-n", help="Name"),
+    color: str = typer.Option(None, "--color", help="Color"),
+    description: str = typer.Option(None, "--description", help="Description"),
+    comments: str = typer.Option(None, "--comments", help="Example queries"),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Update a topic or intent."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.taxonomy_update(
+            client,
+            id,
+            name=name,
+            color=color,
+            description=description,
+            comments=comments,
+        )
+    )
+    typer.echo(result)
+
+
+@app.command("agent-create")
+def agent_create(
+    name: str = typer.Option(..., "--name", help="Agent name"),
+    modality: str = typer.Option(
+        ..., "--modality", help="Modality: Chat, Email, Call, SMS, All"
+    ),
+    agent_type: str = typer.Option(
+        "Customer Support", "--type", help="Type: Customer Support, Generic, etc."
+    ),
+    model: str = typer.Option("GPT-4.1-mini", "--model", help="Model name"),
+    prompt: str = typer.Option("", "--prompt", help="Guidance/guardrails text"),
+    escalation_mode: str = typer.Option(
+        "default",
+        "--escalation-mode",
+        help="Escalation mode: default, email, sms, email_non_opening_hours, ticketing_integration",
+    ),
+    auto_reply: bool = typer.Option(False, "--auto-reply", help="Enable auto-reply"),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Create a new agent."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.agent_create(
+            client,
+            name=name,
+            modality=modality,
+            agent_type=agent_type,
+            model=model,
+            prompt=prompt,
+            escalation_mode=escalation_mode,
+            auto_reply=auto_reply,
+        )
+    )
+    typer.echo(result)
+
+
+@app.command("agent-set-picture")
+def agent_set_picture(
+    id: str = typer.Argument(..., help="Agent ID"),
+    image: str = typer.Option(
+        ..., "--image", "-i", help="Path to image file (PNG, JPG, etc.)"
+    ),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Set an agent's profile picture."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(tools.agent_set_picture(client, id, image))
+    typer.echo(result)
+
+
+@app.command("agent-delete")
+def agent_delete(
+    id: str = typer.Argument(..., help="Agent ID"),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Delete an agent."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(tools.agent_delete(client, id))
+    typer.echo(result)
+
+
+@app.command("knowledge-delete")
+def knowledge_delete(
+    id: str = typer.Argument(..., help="Knowledge item ID"),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Delete a knowledge base item."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(tools.knowledge_delete(client, id))
+    typer.echo(result)
+
+
+@app.command("product-delete")
+def product_delete(
+    id: str = typer.Argument(..., help="Product ID"),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Delete a product."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(tools.product_delete(client, id))
+    typer.echo(result)
+
+
+@app.command("taxonomy-delete")
+def taxonomy_delete(
+    id: str = typer.Argument(..., help="Topic or intent ID"),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Delete a topic or intent."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(tools.taxonomy_delete(client, id))
+    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.54 → applied_cli-0.5.56}/applied_cli/client.py

@@ -382,6 +382,50 @@ class AppliedClient:
                 return None
             return resp.json()
 
+    async def _upload_request(
+        self,
+        method: str,
+        path: str,
+        files: dict[str, Any],
+        data: dict[str, Any] | None = None,
+    ) -> Any:
+        """Make an authenticated multipart file upload request."""
+        headers = {
+            "Authorization": f"Bearer {self.token}",
+        }
+        if self.shop_id:
+            headers["X-Shop-Id"] = self.shop_id
+        url = f"{self.base_url}{path}"
+
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            resp = await client.request(
+                method, url, headers=headers, files=files, data=data or {}
+            )
+
+            if resp.status_code >= 400:
+                detail = ""
+                try:
+                    err_data = resp.json()
+                    if isinstance(err_data, dict):
+                        detail = str(
+                            err_data.get("detail")
+                            or err_data.get("error")
+                            or err_data.get("message")
+                            or ""
+                        )
+                except Exception:
+                    detail = resp.text[:200] if resp.text else ""
+
+                raise AppliedAPIError(
+                    message=f"{method} {path} failed",
+                    status_code=resp.status_code,
+                    detail=detail,
+                )
+
+            if resp.status_code == 204:
+                return None
+            return resp.json()
+
     def _require_shop_id(self, shop_id: str | None = None) -> str:
         resolved_shop_id = shop_id or self.shop_id
         if not resolved_shop_id:
@@ -431,6 +475,59 @@ class AppliedClient:
         )
         return self._normalize_response(data)
 
+    async def create_agent(
+        self,
+        name: str,
+        modality: str,
+        agent_type: str = "Customer Support",
+        model: str = "GPT-4.1-mini",
+        prompt: str = "",
+        escalation_mode: str = "default",
+        auto_reply: bool = False,
+    ) -> dict:
+        """Create a new agent."""
+        body: dict[str, Any] = {
+            "name": name,
+            "modality": modality,
+            "type": agent_type,
+            "model": model,
+            "escalation_mode": escalation_mode,
+            "auto_reply": auto_reply,
+        }
+        if prompt:
+            body["prompt"] = prompt
+        return await self._request("POST", "/v1/agents/", body=body)
+
+    async def update_agent(
+        self,
+        agent_id: str,
+        **kwargs: Any,
+    ) -> dict:
+        """Update an agent's properties."""
+        return await self._request(
+            "PATCH", f"/v1/agents/{agent_id}/", body=kwargs
+        )
+
+    async def update_agent_picture(
+        self,
+        agent_id: str,
+        image_path: str,
+    ) -> dict:
+        """Update an agent's profile picture via file upload."""
+        import mimetypes
+
+        content_type = mimetypes.guess_type(image_path)[0] or "image/png"
+        filename = image_path.rsplit("/", 1)[-1]
+        with open(image_path, "rb") as f:
+            files = {"profile_picture": (filename, f, content_type)}
+            return await self._upload_request(
+                "PATCH", f"/v1/agents/{agent_id}/", files=files
+            )
+
+    async def delete_agent(self, agent_id: str) -> None:
+        """Delete an agent."""
+        await self._request("DELETE", f"/v1/agents/{agent_id}/")
+
     # -------------------------------------------------------------------------
     # Connector Types
     # -------------------------------------------------------------------------
@@ -471,6 +568,40 @@ class AppliedClient:
         data = await self._request("GET", "/v1/property-choices/", params=params)
         return self._normalize_response(data)
 
+    async def create_taxonomy(
+        self,
+        name: str,
+        parent_id: str | None = None,
+        color: str | None = None,
+        description: str | None = None,
+        comments: str | None = None,
+    ) -> dict:
+        """Create a topic or intent (property choice)."""
+        body: dict[str, Any] = {"name": name}
+        if parent_id:
+            body["parent_choice_id"] = parent_id
+        if color:
+            body["color"] = color
+        if description:
+            body["description"] = description
+        if comments:
+            body["comments"] = comments
+        return await self._request("POST", "/v1/property-choices/", body=body)
+
+    async def update_taxonomy(
+        self,
+        choice_id: str,
+        **kwargs: Any,
+    ) -> dict:
+        """Update a topic or intent (property choice)."""
+        return await self._request(
+            "PATCH", f"/v1/property-choices/{choice_id}/", body=kwargs
+        )
+
+    async def delete_taxonomy(self, choice_id: str) -> None:
+        """Delete a topic or intent (property choice)."""
+        await self._request("DELETE", f"/v1/property-choices/{choice_id}/")
+
     # -------------------------------------------------------------------------
     # Analytics
     # -------------------------------------------------------------------------
@@ -1174,6 +1305,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] = {
@@ -1186,6 +1318,8 @@ class AppliedClient:
             body["target_handle"] = target_handle
         if label:
             body["label"] = label
+        if metadata:
+            body["metadata"] = metadata
 
         return await self._request(
             "POST",
@@ -2054,6 +2188,10 @@ class AppliedClient:
             "PATCH", f"/v1/responses/{response_id}/", body=kwargs
         )
 
+    async def delete_response(self, response_id: str) -> None:
+        """Delete a knowledge base item."""
+        await self._request("DELETE", f"/v1/responses/{response_id}/")
+
     # -------------------------------------------------------------------------
     # Products (Content type=Product)
     # -------------------------------------------------------------------------

{applied_cli-0.5.54 → applied_cli-0.5.56}/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.54 → applied_cli-0.5.56}/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(
@@ -5883,3 +5941,208 @@ async def product_delete(
         return _format_error(e)
 
     return f"Product {product_id} deleted successfully."
+
+
+# -----------------------------------------------------------------------------
+# Agent - Create / Update / Delete
+# -----------------------------------------------------------------------------
+
+
+async def agent_create(
+    client: AppliedClient,
+    name: str,
+    modality: str,
+    agent_type: str = "Customer Support",
+    model: str = "GPT-4.1-mini",
+    prompt: str = "",
+    escalation_mode: str = "default",
+    auto_reply: bool = False,
+) -> str:
+    """Create a new agent."""
+    try:
+        agent = await client.create_agent(
+            name=name,
+            modality=modality,
+            agent_type=agent_type,
+            model=model,
+            prompt=prompt,
+            escalation_mode=escalation_mode,
+            auto_reply=auto_reply,
+        )
+    except AppliedAPIError as e:
+        return _format_error(e)
+
+    result = "# Created Agent\n"
+    result += f"id: {agent.get('id')}\n"
+    result += f"name: {agent.get('name')}\n"
+    result += f"modality: {agent.get('modality')}\n"
+    return result
+
+
+async def agent_update(
+    client: AppliedClient,
+    agent_id: str,
+    name: str | None = None,
+    prompt: str | None = None,
+    model: str | None = None,
+    modality: str | None = None,
+    agent_type: str | None = None,
+    escalation_mode: str | None = None,
+    auto_reply: bool | None = None,
+    metadata: dict | None = None,
+) -> str:
+    """Update an agent's properties."""
+    updates: dict = {}
+    if name is not None:
+        updates["name"] = name
+    if prompt is not None:
+        updates["prompt"] = prompt
+    if model is not None:
+        updates["model"] = model
+    if modality is not None:
+        updates["modality"] = modality
+    if agent_type is not None:
+        updates["type"] = agent_type
+    if escalation_mode is not None:
+        updates["escalation_mode"] = escalation_mode
+    if auto_reply is not None:
+        updates["auto_reply"] = auto_reply
+    if metadata is not None:
+        updates["metadata"] = metadata
+
+    try:
+        agent = await client.update_agent(agent_id, **updates)
+    except AppliedAPIError as e:
+        return _format_error(e)
+
+    result = "# Updated Agent\n"
+    result += f"id: {agent.get('id')}\n"
+    result += f"name: {agent.get('name')}\n"
+    result += f"modality: {agent.get('modality')}\n"
+    return result
+
+
+async def agent_set_picture(
+    client: AppliedClient,
+    agent_id: str,
+    image_path: str,
+) -> str:
+    """Set an agent's profile picture from a local file."""
+    import os
+
+    if not os.path.isfile(image_path):
+        return f"Error: File not found: {image_path}"
+
+    try:
+        agent = await client.update_agent_picture(agent_id, image_path)
+    except AppliedAPIError as e:
+        return _format_error(e)
+
+    result = "# Updated Agent Picture\n"
+    result += f"id: {agent.get('id')}\n"
+    result += f"name: {agent.get('name')}\n"
+    result += f"profile_picture: {agent.get('profile_picture')}\n"
+    return result
+
+
+async def agent_delete(
+    client: AppliedClient,
+    agent_id: str,
+) -> str:
+    """Delete an agent."""
+    try:
+        await client.delete_agent(agent_id)
+    except AppliedAPIError as e:
+        return _format_error(e)
+
+    return f"Agent {agent_id} deleted successfully."
+
+
+# -----------------------------------------------------------------------------
+# Knowledge Base - Delete
+# -----------------------------------------------------------------------------
+
+
+async def knowledge_delete(
+    client: AppliedClient,
+    knowledge_id: str,
+) -> str:
+    """Delete a knowledge base item."""
+    try:
+        await client.delete_response(knowledge_id)
+    except AppliedAPIError as e:
+        return _format_error(e)
+
+    return f"Knowledge item {knowledge_id} deleted successfully."
+
+
+# -----------------------------------------------------------------------------
+# Taxonomy - Create / Update / Delete
+# -----------------------------------------------------------------------------
+
+
+async def taxonomy_create(
+    client: AppliedClient,
+    name: str,
+    parent_id: str | None = None,
+    color: str | None = None,
+    description: str | None = None,
+    comments: str | None = None,
+) -> str:
+    """Create a topic or intent."""
+    try:
+        item = await client.create_taxonomy(
+            name=name,
+            parent_id=parent_id,
+            color=color,
+            description=description,
+            comments=comments,
+        )
+    except AppliedAPIError as e:
+        return _format_error(e)
+
+    item_type = "intent" if parent_id else "topic"
+    result = f"# Created {item_type.title()}\n"
+    result += f"id: {item.get('id')}\n"
+    result += f"name: {item.get('name')}\n"
+    return result
+
+
+async def taxonomy_update(
+    client: AppliedClient,
+    choice_id: str,
+    name: str | None = None,
+    color: str | None = None,
+    description: str | None = None,
+    comments: str | None = None,
+) -> str:
+    """Update a topic or intent."""
+    updates: dict = {}
+    if name is not None:
+        updates["name"] = name
+    if color is not None:
+        updates["color"] = color
+    if description is not None:
+        updates["description"] = description
+    if comments is not None:
+        updates["comments"] = comments
+
+    try:
+        item = await client.update_taxonomy(choice_id, **updates)
+    except AppliedAPIError as e:
+        return _format_error(e)
+
+    return f"# Updated Taxonomy Item\nid: {item.get('id')}\nname: {item.get('name')}"
+
+
+async def taxonomy_delete(
+    client: AppliedClient,
+    choice_id: str,
+) -> str:
+    """Delete a topic or intent."""
+    try:
+        await client.delete_taxonomy(choice_id)
+    except AppliedAPIError as e:
+        return _format_error(e)
+
+    return f"Taxonomy item {choice_id} deleted successfully."

{applied_cli-0.5.54 → applied_cli-0.5.56}/applied_cli.egg-info/PKG-INFO

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

{applied_cli-0.5.54 → applied_cli-0.5.56}/pyproject.toml

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