luge-cli 0.17.0__py3-none-any.whl

luge_cli/__init__.py

@@ -0,0 +1,7 @@
+"""Luge kanban CLI — read and work boards over the Luge REST API."""
+
+from importlib.metadata import version
+
+# Single source of truth is pyproject's version, read from the installed
+# distribution metadata — no literal to keep in sync here.
+__version__ = version("luge-cli")

luge_cli/__main__.py

@@ -0,0 +1,85 @@
+"""Entry point: assembles the Typer app and wraps it in one error boundary."""
+
+from __future__ import annotations
+
+import sys
+
+import typer
+
+from . import __version__, render
+from .commands import (
+    activity_cmd,
+    agent_cmd,
+    artifact_cmd,
+    auth_cmd,
+    board_cmd,
+    card,
+    channel_cmd,
+    claude_cmd,
+    colleagues_cmd,
+    dm_cmd,
+    schedule_cmd,
+    settings_cmd,
+    skill_cmd,
+    webhook_cmd,
+    workflow_cmd,
+)
+from .errors import LugeCliError
+
+app = typer.Typer(
+    name="luge-cli",
+    help="Read and work your Luge kanban boards from the command line.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+for module in (
+    board_cmd,
+    card,
+    schedule_cmd,
+    workflow_cmd,
+    activity_cmd,
+    channel_cmd,
+    dm_cmd,
+    agent_cmd,
+    colleagues_cmd,
+    artifact_cmd,
+    webhook_cmd,
+    skill_cmd,
+    settings_cmd,
+    auth_cmd,
+    claude_cmd,
+):
+    module.register(app)
+
+
+def _show_version(value: bool) -> None:
+    if value:
+        typer.echo(__version__)
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        callback=_show_version,
+        is_eager=True,
+        help="Show the version and exit.",
+    ),
+) -> None:
+    """Read and work your Luge kanban boards from the command line."""
+
+
+def run() -> None:
+    """Console-script entry: run the app, surface expected errors cleanly."""
+    try:
+        app()
+    except LugeCliError as exc:
+        render.error(str(exc))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    run()

luge_cli/client/__init__.py

@@ -0,0 +1,37 @@
+"""HTTP client for the Luge API. ``LugeClient`` composes per-domain endpoint
+mixins onto the transport core; import it (and ``LugeError``) from here."""
+
+from __future__ import annotations
+
+from .artifacts import ArtifactsMixin
+from .automations import AutomationsMixin
+from .base import BaseClient, LugeError
+from .boards import BoardsMixin
+from .channels import ChannelsMixin
+from .chat import ChatMixin
+from .employees import EmployeesMixin
+from .schedules import SchedulesMixin
+from .settings import SettingsMixin
+from .skills import SkillsMixin
+from .webhooks import WebhooksMixin
+from .workflows import WorkflowsMixin
+
+
+class LugeClient(
+    BoardsMixin,
+    SchedulesMixin,
+    WorkflowsMixin,
+    AutomationsMixin,
+    SettingsMixin,
+    ChannelsMixin,
+    ChatMixin,
+    ArtifactsMixin,
+    WebhooksMixin,
+    EmployeesMixin,
+    SkillsMixin,
+    BaseClient,
+):
+    """One method per Luge endpoint the CLI needs, grouped by domain mixin."""
+
+
+__all__ = ["LugeClient", "LugeError"]

luge_cli/client/artifacts.py

@@ -0,0 +1,31 @@
+"""Artifact endpoints (`/artifacts`).
+
+An artifact is a per-room deliverable (markdown/html/code/pdf). It always lives
+in a room — the ``room_id`` is a conversation/channel id (a channel's
+``conversation_id``). There is no update-in-place: ``POST`` always inserts.
+"""
+
+from __future__ import annotations
+
+
+class ArtifactsMixin:
+    """Mixed into ``LugeClient``; uses ``_request`` from ``BaseClient``."""
+
+    def list_room_artifacts(self, room_id: str) -> dict:
+        """All artifacts in one room, with full content."""
+        return self._request("GET", f"artifacts/rooms/{room_id}")
+
+    def my_artifacts(self, limit: int = 50, offset: int = 0) -> dict:
+        """Artifacts across the caller's own rooms (summaries, no content)."""
+        return self._request("GET", "artifacts/mine", params={"limit": limit, "offset": offset})
+
+    def get_artifact(self, artifact_id: str) -> dict:
+        return self._request("GET", f"artifacts/{artifact_id}")
+
+    def create_artifact(self, body: dict) -> dict:
+        """Create an artifact in a room. ``body`` needs ``room_id``, ``title``,
+        ``content``; ``content_type`` and ``language`` are optional."""
+        return self._request("POST", "artifacts", json=body)
+
+    def delete_artifact(self, artifact_id: str) -> dict:
+        return self._request("DELETE", f"artifacts/{artifact_id}")

luge_cli/client/automations.py

@@ -0,0 +1,46 @@
+"""Automation endpoints (`/automations`) — the cross-surface run activity view.
+
+An automation is one Execution (a run) projected across every trigger surface
+(webhook, schedule, workflow, notetaker, agent_task, outbound_call). There is no
+create — runs are born when a trigger fires. ``automation_id`` (the room id, the
+``id`` field of a list row) is what get/retry key on.
+"""
+
+from __future__ import annotations
+
+
+class AutomationsMixin:
+    """Mixed into ``LugeClient``; uses ``_request`` from ``BaseClient``."""
+
+    def list_automations(
+        self,
+        status: str | None = None,
+        trigger_kind: str | None = None,
+        search: str | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> dict:
+        return self._request(
+            "GET",
+            "automations",
+            params={
+                "status": status,
+                "trigger_kind": trigger_kind,
+                "search": search,
+                "limit": limit,
+                "offset": offset,
+            },
+        )
+
+    def get_automation(self, automation_id: str) -> dict:
+        """Detail for one run: summary + full message thread + human tasks."""
+        return self._request("GET", f"automations/{automation_id}")
+
+    def retry_automation(self, automation_id: str) -> dict:
+        """Re-run a failed/cancelled automation's underlying Execution."""
+        return self._request("POST", f"automations/{automation_id}/retry")
+
+    def automation_stats(self, days: int = 14, trigger_kind: str | None = None) -> dict:
+        return self._request(
+            "GET", "automations/stats", params={"days": days, "trigger_kind": trigger_kind}
+        )

luge_cli/client/base.py

@@ -0,0 +1,81 @@
+"""Transport core for the Luge client: request plumbing and error mapping.
+
+``base_url`` is the full API base including any deployment prefix (e.g.
+``https://luge.example.com/api``). Request paths are **relative** (no leading
+slash) so httpx joins them onto that base rather than replacing its path — a
+leading slash would drop the ``/api`` prefix.
+
+Per-domain endpoint methods live in sibling mixins (``boards``, ``schedules``,
+…); ``LugeClient`` in ``__init__`` composes them onto this base.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Self
+
+import httpx
+
+from ..errors import LugeCliError
+
+
+class LugeError(LugeCliError):
+    """An API call failed — transport error or non-2xx response."""
+
+
+_STATUS_HINTS = {
+    401: "Unauthorized — check your API token (`luge-cli auth show`).",
+    403: "Forbidden — your token cannot access this resource.",
+    404: "Not found — no such resource, or you lack access.",
+}
+
+
+class BaseClient:
+    def __init__(
+        self,
+        base_url: str,
+        token: str,
+        *,
+        transport: httpx.BaseTransport | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self._http = httpx.Client(
+            base_url=base_url.rstrip("/") + "/",
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=timeout,
+            transport=transport,
+        )
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self._http.close()
+
+    def _raw(self, method: str, path: str, **kwargs: Any) -> httpx.Response:
+        # Drop None query params — httpx would send them as an empty `key=`,
+        # which the API reads as an empty-string filter, not an absent one.
+        params = kwargs.get("params")
+        if isinstance(params, dict):
+            kwargs["params"] = {k: v for k, v in params.items() if v is not None}
+        try:
+            resp = self._http.request(method, path, **kwargs)
+        except httpx.RequestError as exc:
+            raise LugeError(f"Cannot reach Luge at {self._http.base_url}: {exc}") from exc
+        if resp.status_code >= 400:
+            hint = _STATUS_HINTS.get(resp.status_code) or self._detail(resp)
+            raise LugeError(f"Luge API error {resp.status_code}: {hint}")
+        return resp
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> Any:
+        resp = self._raw(method, path, **kwargs)
+        return resp.json() if resp.content else {}
+
+    @staticmethod
+    def _detail(resp: httpx.Response) -> str:
+        try:
+            body = resp.json()
+        except ValueError:
+            return resp.text[:200] or resp.reason_phrase
+        if isinstance(body, dict) and "detail" in body:
+            return str(body["detail"])
+        return resp.text[:200] or resp.reason_phrase

luge_cli/client/boards.py

@@ -0,0 +1,78 @@
+"""Board & card endpoints — one method per endpoint the CLI needs."""
+
+from __future__ import annotations
+
+import mimetypes
+from pathlib import Path
+
+import httpx
+
+
+class BoardsMixin:
+    """Board, card, comment and attachment endpoints. Mixed into ``LugeClient``;
+    relies on the transport helpers (``_raw`` / ``_request``) from ``BaseClient``."""
+
+    # ── Reads ─────────────────────────────────────────────────────────────
+    def list_boards(self, limit: int = 100, offset: int = 0) -> dict:
+        return self._request("GET", "boards", params={"limit": limit, "offset": offset})
+
+    def get_board(self, board_id: str) -> dict:
+        return self._request("GET", f"boards/{board_id}")
+
+    def assigned_cards(self, limit: int = 100) -> dict:
+        return self._request("GET", "boards/assigned-cards", params={"limit": limit})
+
+    def list_comments(self, board_id: str, card_id: str) -> dict:
+        return self._request("GET", f"boards/{board_id}/cards/{card_id}/comments")
+
+    def list_attachments(self, board_id: str, card_id: str) -> dict:
+        return self._request("GET", f"boards/{board_id}/cards/{card_id}/attachments")
+
+    def attachment_content(self, board_id: str, card_id: str, link_id: str) -> httpx.Response:
+        """Raw content of one attachment (artifact JSON or document bytes),
+        served through the board façade — board read access is enough."""
+        return self._raw("GET", f"boards/{board_id}/cards/{card_id}/attachments/{link_id}/content")
+
+    # ── Writes ────────────────────────────────────────────────────────────
+    def create_card(self, board_id: str, body: dict) -> dict:
+        """Create a card in a board column. ``body`` needs ``column_id`` and
+        ``title``; notes / tags / priority / color / due_date / assignee_id are
+        optional. Returns the created card."""
+        return self._request("POST", f"boards/{board_id}/cards", json=body)
+
+    def comment_card(self, board_id: str, card_id: str, body: str) -> dict:
+        return self._request(
+            "POST", f"boards/{board_id}/cards/{card_id}/comments", json={"body": body}
+        )
+
+    def move_card(self, board_id: str, card_id: str, column_id: str, position: int = 0) -> dict:
+        return self._request(
+            "PATCH",
+            f"boards/{board_id}/cards/{card_id}/move",
+            json={"column_id": column_id, "position": position},
+        )
+
+    def set_completed(self, board_id: str, card_id: str, completed: bool) -> dict:
+        return self._request(
+            "PATCH", f"boards/{board_id}/cards/{card_id}", json={"completed": completed}
+        )
+
+    def upload_document(self, path: Path) -> dict:
+        """Upload a local file as a document (the tenant corpus). Returns the
+        created document, whose ``id`` the card-attach step then links."""
+        ctype = mimetypes.guess_type(path.name)[0] or "application/octet-stream"
+        with path.open("rb") as handle:
+            return self._request("POST", "documents", files={"file": (path.name, handle, ctype)})
+
+    def attach_document(self, board_id: str, card_id: str, document_id: str) -> dict:
+        """Link an existing document to a card. Returns the card's refreshed
+        attachment list."""
+        return self._request(
+            "POST",
+            f"boards/{board_id}/cards/{card_id}/attachments",
+            json={"document_id": document_id},
+        )
+
+    def detach_attachment(self, board_id: str, card_id: str, link_id: str) -> dict:
+        """Detach an attachment from a card (the document itself is untouched)."""
+        return self._request("DELETE", f"boards/{board_id}/cards/{card_id}/attachments/{link_id}")

luge_cli/client/channels.py

@@ -0,0 +1,42 @@
+"""Team chat-channel endpoints (`/team-channels`) — the group-chat surface.
+
+A channel is a named, multi-member room. Messages live on the backing room
+(``conversation_id``, materialised lazily). Posting a plain message is silent;
+the AI answers only when the text ``@luge``-mentions it and ``luge_enabled``.
+"""
+
+from __future__ import annotations
+
+
+class ChannelsMixin:
+    """Mixed into ``LugeClient``; uses ``_request`` from ``BaseClient``."""
+
+    def list_channels(self) -> dict:
+        return self._request("GET", "team-channels")
+
+    def browse_channels(self) -> dict:
+        """Public channels the caller can join but hasn't yet."""
+        return self._request("GET", "team-channels/browse")
+
+    def get_channel(self, channel_id: str) -> dict:
+        return self._request("GET", f"team-channels/{channel_id}")
+
+    def channel_messages(self, channel_id: str, limit: int = 50, offset: int = 0) -> dict:
+        """A channel's message history (oldest-first). Also returns the backing
+        ``conversation_id`` (forces room materialisation)."""
+        return self._request(
+            "GET", f"team-channels/{channel_id}/messages", params={"limit": limit, "offset": offset}
+        )
+
+    def post_channel_message(self, channel_id: str, body: str) -> dict:
+        """Post a message. Silent unless the body ``@luge``-mentions the agent."""
+        return self._request("POST", f"team-channels/{channel_id}/messages", json={"body": body})
+
+    def join_channel(self, channel_id: str) -> dict:
+        return self._request("POST", f"team-channels/{channel_id}/join")
+
+    def leave_channel(self, channel_id: str) -> dict:
+        return self._request("POST", f"team-channels/{channel_id}/leave")
+
+    def create_channel(self, body: dict) -> dict:
+        return self._request("POST", "team-channels", json=body)

luge_cli/client/chat.py

@@ -0,0 +1,56 @@
+"""Conversation + agent-chat endpoints (`/conversations`, `/chat`).
+
+Two send surfaces with opposite behavior:
+- ``post_conversation_message`` appends a plain user message — no agent runs.
+- ``chat`` dispatches through the agent pipeline and DOES trigger an AI reply,
+  asynchronously (returns ``{conversation_id, room_id, status}``; the reply lands
+  later — the CLI is fire-and-forget for now, WebSocket streaming is a follow-up).
+"""
+
+from __future__ import annotations
+
+
+class ChatMixin:
+    """Mixed into ``LugeClient``; uses ``_request`` from ``BaseClient``."""
+
+    def list_conversations(self, conversation_type: str = "session", limit: int = 50) -> dict:
+        # The list route is declared with a trailing slash only; keep it so the
+        # client (which does not follow redirects) hits it directly.
+        return self._request(
+            "GET", "conversations/", params={"conversation_type": conversation_type, "limit": limit}
+        )
+
+    def get_conversation(self, conversation_id: str) -> dict:
+        return self._request("GET", f"conversations/{conversation_id}")
+
+    def create_dm(self, colleague_id: str) -> dict:
+        """Create or reopen a 1:1 DM with a colleague (their employee/user id).
+        Returns ``{conversation_id, is_new, participant}``."""
+        return self._request("POST", "conversations/dm", json={"colleague_id": colleague_id})
+
+    def conversation_messages(
+        self, conversation_id: str, limit: int = 50, before: str | None = None
+    ) -> dict:
+        return self._request(
+            "GET",
+            f"conversations/{conversation_id}/messages",
+            params={"limit": limit, "before": before},
+        )
+
+    def post_conversation_message(self, conversation_id: str, body: str) -> dict:
+        """Append a plain user message (no agent is invoked)."""
+        return self._request(
+            "POST", f"conversations/{conversation_id}/messages", json={"body": body}
+        )
+
+    def chat(
+        self, prompt: str, conversation_id: str | None = None, agent_id: str | None = None
+    ) -> dict:
+        """Send a prompt to an agent — triggers a reply. Returns immediately with
+        ``{conversation_id, room_id, status}``; the reply arrives asynchronously.
+        Omit ``conversation_id`` to start a new conversation."""
+        return self._request(
+            "POST",
+            "chat",
+            json={"prompt": prompt, "conversation_id": conversation_id, "agent_id": agent_id},
+        )

luge_cli/client/employees.py

@@ -0,0 +1,25 @@
+"""Colleague / employee directory (`/employees`).
+
+The full people directory (broader than the tenant's team members) — the source
+for finding someone to DM. Member-safe (``profile.read.others``).
+"""
+
+from __future__ import annotations
+
+
+class EmployeesMixin:
+    """Mixed into ``LugeClient``; uses ``_request`` from ``BaseClient``."""
+
+    def list_colleagues(
+        self, limit: int = 100, offset: int = 0, employee_type: str | None = None
+    ) -> dict:
+        # The list route is declared with a trailing slash only.
+        return self._request(
+            "GET",
+            "employees/",
+            params={"limit": limit, "offset": offset, "employee_type": employee_type},
+        )
+
+    def get_colleague(self, employee_id: str) -> dict:
+        """One colleague's profile (role, department, skills)."""
+        return self._request("GET", f"employees/{employee_id}")

luge_cli/client/schedules.py

@@ -0,0 +1,40 @@
+"""Scheduled-task endpoints (`/scheduled-tasks`).
+
+A scheduled task is a recurring prompt that fires an agent run. The schedule is
+structured (``recurrence_type`` + ``recurrence_config`` + ``times_of_day``), not
+a cron string — the CLI builds that body from ergonomic flags (see
+``schedule_spec``). Run history is not on the task; it surfaces via automations.
+"""
+
+from __future__ import annotations
+
+
+class SchedulesMixin:
+    """Mixed into ``LugeClient``; uses ``_request`` from ``BaseClient``."""
+
+    def list_schedules(self, enabled_only: bool = False, limit: int = 100, offset: int = 0) -> dict:
+        return self._request(
+            "GET",
+            "scheduled-tasks",
+            params={"enabled_only": enabled_only, "limit": limit, "offset": offset},
+        )
+
+    def get_schedule(self, task_id: str) -> dict:
+        return self._request("GET", f"scheduled-tasks/{task_id}")
+
+    def create_schedule(self, body: dict) -> dict:
+        return self._request("POST", "scheduled-tasks", json=body)
+
+    def update_schedule(self, task_id: str, body: dict) -> dict:
+        return self._request("PUT", f"scheduled-tasks/{task_id}", json=body)
+
+    def delete_schedule(self, task_id: str) -> dict:
+        return self._request("DELETE", f"scheduled-tasks/{task_id}")
+
+    def toggle_schedule(self, task_id: str) -> dict:
+        """Flip ``enabled`` (pause / resume); server recomputes ``next_run_at``."""
+        return self._request("POST", f"scheduled-tasks/{task_id}/toggle")
+
+    def trigger_schedule(self, task_id: str) -> dict:
+        """Run the task now. Returns a run summary (id, status, scheduled_for)."""
+        return self._request("POST", f"scheduled-tasks/{task_id}/trigger")

luge_cli/client/settings.py

@@ -0,0 +1,41 @@
+"""Tenant settings endpoints (`/settings/...`).
+
+The tenant-wide slices (memory / pii / compliance / web-search / tenant) are
+single objects at ``settings/<slug>`` — one generic get/put pair covers them
+(PUT is a partial patch: only the keys you send are written). Agents, the
+provider catalogue, team members and credentials are collection reads.
+
+Most of these need an **admin-role** key; agents, providers and team are the
+member-safe reads (AGENT_USE / MEMBER_READ).
+"""
+
+from __future__ import annotations
+
+
+class SettingsMixin:
+    """Mixed into ``LugeClient``; uses ``_request`` from ``BaseClient``."""
+
+    def get_settings(self, slug: str) -> dict:
+        """Read one tenant-settings slice (``memory``/``pii``/``compliance``/
+        ``web-search``/``tenant``)."""
+        return self._request("GET", f"settings/{slug}")
+
+    def put_settings(self, slug: str, body: dict) -> dict:
+        """Partial-patch one tenant-settings slice — only the keys in ``body``
+        are written."""
+        return self._request("PUT", f"settings/{slug}", json=body)
+
+    def list_agents(self) -> dict:
+        return self._request("GET", "settings/agents")
+
+    def get_agent(self, agent_id: str) -> dict:
+        return self._request("GET", f"settings/agents/{agent_id}")
+
+    def providers_catalog(self) -> dict:
+        return self._request("GET", "settings/providers/catalog")
+
+    def list_team(self) -> dict:
+        return self._request("GET", "settings/team/members")
+
+    def list_credentials(self) -> dict:
+        return self._request("GET", "settings/credentials")

luge_cli/client/skills.py

@@ -0,0 +1,32 @@
+"""Personal Luge skills (`/skills`).
+
+A skill is an authored instruction set (name, description, instructions body,
+required tools, trigger phrases) that agents can use. These methods target the
+caller's **personal** skills (``scope=personal``, visible only to them). Reads
+are member-safe; create/update/delete need the skill-manage capability.
+"""
+
+from __future__ import annotations
+
+
+class SkillsMixin:
+    """Mixed into ``LugeClient``; uses ``_request`` from ``BaseClient``."""
+
+    def list_skills(self) -> dict:
+        """All skills visible to the caller (tenant + personal). Filter on
+        ``scope == "personal"`` for the caller's own."""
+        return self._request("GET", "skills/list")
+
+    def get_personal_skill(self, skill_name: str) -> dict:
+        return self._request("GET", f"skills/personal/{skill_name}")
+
+    def create_personal_skill(self, body: dict) -> dict:
+        """Create a personal skill. ``body`` needs ``skill_name``; description /
+        instructions / requires / triggers are optional."""
+        return self._request("POST", "skills/personal", json=body)
+
+    def update_personal_skill(self, skill_name: str, body: dict) -> dict:
+        return self._request("PUT", f"skills/personal/{skill_name}", json=body)
+
+    def delete_personal_skill(self, skill_name: str) -> dict:
+        return self._request("DELETE", f"skills/personal/{skill_name}")

luge_cli/client/webhooks.py

@@ -0,0 +1,42 @@
+"""Inbound webhook-endpoint management (`/settings/webhook-endpoints`).
+
+A webhook endpoint is a receiver Luge hosts: an external system POSTs to its
+``inbound_url``, and the delivery is routed to the endpoint's destination (an
+agent or a workflow) or just logged. The CLI manages these endpoints and inspects
+their deliveries — it does not receive the webhooks itself. All member-safe.
+"""
+
+from __future__ import annotations
+
+
+class WebhooksMixin:
+    """Mixed into ``LugeClient``; uses ``_request`` from ``BaseClient``."""
+
+    def list_webhooks(self) -> dict:
+        return self._request("GET", "settings/webhook-endpoints")
+
+    def get_webhook(self, endpoint_id: str) -> dict:
+        return self._request("GET", f"settings/webhook-endpoints/{endpoint_id}")
+
+    def create_webhook(self, body: dict) -> dict:
+        """Create an endpoint. The response carries ``inbound_url`` and (once)
+        the signing ``secret`` — capture it, it is not returned again."""
+        return self._request("POST", "settings/webhook-endpoints", json=body)
+
+    def update_webhook(self, endpoint_id: str, body: dict) -> dict:
+        return self._request("PUT", f"settings/webhook-endpoints/{endpoint_id}", json=body)
+
+    def delete_webhook(self, endpoint_id: str) -> dict:
+        return self._request("DELETE", f"settings/webhook-endpoints/{endpoint_id}")
+
+    def webhook_deliveries(self, endpoint_id: str, limit: int = 50) -> dict:
+        """The inbound-delivery journal for one endpoint (what has arrived)."""
+        return self._request(
+            "GET", f"settings/webhook-endpoints/{endpoint_id}/deliveries", params={"limit": limit}
+        )
+
+    def webhook_delivery(self, endpoint_id: str, delivery_id: str) -> dict:
+        """One delivery in full (payload + headers)."""
+        return self._request(
+            "GET", f"settings/webhook-endpoints/{endpoint_id}/deliveries/{delivery_id}"
+        )