openedx-mcp 0.1.0__py3-none-any.whl

openedx_mcp/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.1.0"
+default_app_config = "openedx_mcp.apps.MCPLmsConfig"

openedx_mcp/admin.py

@@ -0,0 +1,67 @@
+"""
+Django admin for MCP keys — this IS the "console" for key creation.
+
+No custom MFE, no GraphQL. An is_staff user goes to /admin/openedx_mcp/mcpkey/,
+clicks Add, picks the acting user + scopes, and saves. The raw key is generated
+server-side and surfaced ONCE via a success message (it is never stored in the
+clear, so it cannot be shown again). Thereafter the row shows only a prefix.
+"""
+from datetime import timedelta
+
+from django.conf import settings
+from django.contrib import admin, messages
+from django.utils import timezone
+
+from .models import MCPAuditLog, MCPKey, generate_raw_key
+
+
+@admin.register(MCPKey)
+class MCPKeyAdmin(admin.ModelAdmin):
+    list_display = ("name", "user", "key_prefix", "scopes", "is_revoked", "expires_at",
+                    "last_used_at", "created_at")
+    list_filter = ("is_revoked", "created_at")
+    search_fields = ("name", "user__username", "user__email", "key_prefix")
+    readonly_fields = ("key_prefix", "key_hash", "last_used_at", "created_at")
+    actions = ["revoke_keys"]
+
+    def get_fields(self, request, obj=None):
+        if obj is None:  # add form
+            return ("user", "name", "scopes", "expires_at")
+        return ("user", "name", "scopes", "is_revoked", "expires_at",
+                "key_prefix", "last_used_at", "created_at")
+
+    def save_model(self, request, obj, form, change):
+        if not change:  # creating: mint the secret now, show it once
+            raw = generate_raw_key()
+            obj.set_raw_key(raw)
+            # Auto-set expiry from the configured default TTL when left blank.
+            if obj.expires_at is None:
+                ttl_days = getattr(settings, "OPENEDX_MCP_DEFAULT_KEY_TTL_DAYS", None)
+                if ttl_days:
+                    obj.expires_at = timezone.now() + timedelta(days=ttl_days)
+            super().save_model(request, obj, form, change)
+            messages.warning(
+                request,
+                "MCP key created. Copy it now — it will not be shown again:\n%s" % raw,
+            )
+        else:
+            super().save_model(request, obj, form, change)
+
+    @admin.action(description="Revoke selected keys")
+    def revoke_keys(self, request, queryset):
+        n = queryset.update(is_revoked=True)
+        self.message_user(request, f"Revoked {n} key(s).", messages.SUCCESS)
+
+
+@admin.register(MCPAuditLog)
+class MCPAuditLogAdmin(admin.ModelAdmin):
+    list_display = ("created_at", "tool", "outcome", "user", "affected_count")
+    list_filter = ("outcome", "tool", "created_at")
+    search_fields = ("tool", "user__username", "error")
+    readonly_fields = [f.name for f in MCPAuditLog._meta.fields]
+
+    def has_add_permission(self, request):
+        return False  # append-only, written by the facade
+
+    def has_change_permission(self, request, obj=None):
+        return False

openedx_mcp/api/mcp/auth.py

@@ -0,0 +1,95 @@
+"""
+Authentication + authorization for the MCP facade.
+
+Two accepted credentials, in priority order:
+
+  1. X-MCP-Key  — an openedx_mcp.MCPKey bearer token (the primary path; keys are
+     minted from the Django admin). Resolves to the key's acting user.
+  2. The host platform's own JwtAuthentication / SessionAuthentication — so the
+     same endpoints can also be driven directly with an Open edX JWT that already
+     carries is_staff/is_superuser (oauth_dispatch encodes both claims). This is
+     what the key-management endpoints themselves use.
+
+Whichever path authenticates, the authorization rule is identical and re-checked
+LIVE on every request: the acting user must be is_staff or is_superuser right now.
+A key does not cache privilege — demote the user and every key they hold dies on
+the next call. `scopes` on a key only narrow, never widen.
+"""
+import logging
+
+from django.contrib.auth import get_user_model
+from django.utils import timezone
+from rest_framework import authentication, exceptions, permissions
+
+from ...models import MCPKey, hash_key
+
+log = logging.getLogger(__name__)
+User = get_user_model()
+
+MCP_KEY_HEADER = "X-MCP-Key"
+
+
+class MCPKeyAuthentication(authentication.BaseAuthentication):
+    """Authenticate by X-MCP-Key. Returns None (not an error) when absent, so it
+    composes with JWT/Session authenticators on the same view."""
+
+    def authenticate(self, request):
+        raw = request.headers.get(MCP_KEY_HEADER)
+        if not raw:
+            return None
+
+        key = MCPKey.objects.filter(key_hash=hash_key(raw)).select_related("user").first()
+        if key is None:
+            raise exceptions.AuthenticationFailed("Invalid MCP key.")
+        if key.is_revoked:
+            raise exceptions.AuthenticationFailed("This MCP key has been revoked.")
+        if key.is_expired:
+            raise exceptions.AuthenticationFailed("This MCP key has expired.")
+
+        # Best-effort last-used telemetry; never blocks the request.
+        MCPKey.objects.filter(pk=key.pk).update(last_used_at=timezone.now())
+        return (key.user, key)
+
+    def authenticate_header(self, request):
+        return MCP_KEY_HEADER
+
+
+def get_key(request):
+    """The MCPKey backing this request, or None when authed by JWT/session."""
+    auth = getattr(request, "auth", None)
+    return auth if isinstance(auth, MCPKey) else None
+
+
+def granted_scopes(request):
+    """Scopes available on this request. A JWT/session admin (no key) has all
+    scopes; a key is limited to its own granted set."""
+    key = get_key(request)
+    if key is None:
+        from ...models import ALL_SCOPES
+        return set(ALL_SCOPES)
+    return key.granted_scopes()
+
+
+class IsStaffOrSuperuser(permissions.BasePermission):
+    """Live authority check — the acting user must currently be staff/superuser.
+    This is the single gate; it runs on every request regardless of credential."""
+
+    message = "This endpoint requires a staff or superuser account."
+
+    def has_permission(self, request, view):
+        user = getattr(request, "user", None)
+        return bool(user and user.is_authenticated and (user.is_staff or user.is_superuser))
+
+
+def require_scopes(request, *needed):
+    """Raise PermissionDenied unless the request's credential carries every scope.
+    Superuser bypasses scope narrowing entirely."""
+    if request.user.is_superuser:
+        return
+    have = granted_scopes(request)
+    missing = set(needed) - have
+    if missing:
+        raise exceptions.PermissionDenied(
+            {"error": "Missing scope(s).", "required": sorted(needed),
+             "missing": sorted(missing)}
+        )

openedx_mcp/api/mcp/authoring_views.py

@@ -0,0 +1,105 @@
+"""CMS course-authoring tool endpoints. Loaded only in the Studio process
+(/api/mcp/cms/). Reads need read; writes need write:courses; delete adds
+destructive. Draft edits apply immediately; delete/publish use confirm handshake."""
+from rest_framework.response import Response
+
+from ...models import Scope
+from ...native import authoring as nau
+from .base import MCPView
+from .guards import audited_write
+
+
+class CourseOutlineView(MCPView):
+    def get(self, request, course_id):
+        outline = nau.read_outline(request.user, course_id)
+        if outline is None:
+            return Response({"error": "No such course."}, status=404)
+        return Response(outline)
+
+
+class CreateCourseView(MCPView):
+    @audited_write("create_course", scope=Scope.WRITE_COURSES, require_confirm=True)
+    def post(self, request, confirmed=True):
+        d = request.data
+        if not confirmed:
+            return Response({"would_create": {"org": d["org"], "number": d["number"],
+                                              "run": d["run"], "name": d["display_name"]}})
+        return Response(nau.create_course(request.user, d["org"], d["number"], d["run"],
+                                          d["display_name"], d.get("extra_fields"))), 1
+
+
+class CloneCourseView(MCPView):
+    @audited_write("clone_course", scope=Scope.WRITE_COURSES, require_confirm=True)
+    def post(self, request, confirmed=True):
+        d = request.data
+        if not confirmed:
+            return Response({"would_clone": d["source_course_id"],
+                             "into": f"{d['org']}+{d['number']}+{d['run']}"})
+        return Response(nau.clone_course(request.user, d["source_course_id"], d["org"],
+                                         d["number"], d["run"], d.get("display_name"))), 1
+
+
+class DeleteCourseView(MCPView):
+    @audited_write("delete_course", scope=Scope.DESTRUCTIVE, require_confirm=True)
+    def post(self, request, confirmed=True):
+        d = request.data
+        if not confirmed:
+            return Response({"would_delete": d["course_id"]})
+        return Response(nau.delete_course(request.user, d["course_id"],
+                                          keep_instructors=d.get("keep_instructors", False))), 1
+
+
+class CreateBlockView(MCPView):
+    @audited_write("create_xblock", scope=Scope.WRITE_COURSES, require_confirm=False)
+    def post(self, request, confirmed=True):
+        d = request.data
+        return Response(nau.create_block(request.user, d["parent_locator"], d["category"],
+                                         d.get("display_name"), d.get("boilerplate"))), 1
+
+
+class CreateBlockTreeView(MCPView):
+    """Create a whole subtree (sections→subsections→units→components) in one call."""
+    @audited_write("create_xblock", scope=Scope.WRITE_COURSES, require_confirm=False)
+    def post(self, request, confirmed=True):
+        d = request.data
+        result = nau.create_block_tree(request.user, d["parent_locator"], d["nodes"])
+        # affected = count of blocks created across the tree
+        def _count(nodes):
+            return sum(1 + _count(n.get("children", [])) for n in nodes)
+        return Response(result), _count(result.get("created", []))
+
+
+class UpdateBlockView(MCPView):
+    @audited_write("update_xblock", scope=Scope.WRITE_COURSES, require_confirm=False)
+    def post(self, request, confirmed=True):
+        d = request.data
+        return Response(nau.update_block(request.user, d["locator"], data=d.get("data"),
+                                         metadata=d.get("metadata"), fields=d.get("fields"),
+                                         publish=d.get("publish"))), 1
+
+
+class PublishBlockView(MCPView):
+    @audited_write("publish_xblock", scope=Scope.WRITE_COURSES, require_confirm=True)
+    def post(self, request, confirmed=True):
+        d = request.data
+        if not confirmed:
+            return Response({"would_publish": d["locator"]})
+        return Response(nau.publish_block(request.user, d["locator"])), 1
+
+
+class DeleteBlockView(MCPView):
+    @audited_write("delete_xblock", scope=Scope.WRITE_COURSES, require_confirm=True)
+    def post(self, request, confirmed=True):
+        d = request.data
+        if not confirmed:
+            return Response({"would_delete": d["locator"]})
+        return Response(nau.delete_block(request.user, d["locator"])), 1
+
+
+class UpdateCourseSettingsView(MCPView):
+    @audited_write("update_course_settings", scope=Scope.WRITE_COURSES, require_confirm=False)
+    def post(self, request, confirmed=True):
+        d = request.data
+        return Response(nau.update_course_settings(
+            request.user, d["course_id"], details=d.get("details"),
+            grading=d.get("grading"), advanced=d.get("advanced"))), 1

openedx_mcp/api/mcp/base.py

@@ -0,0 +1,24 @@
+"""
+Shared DRF base for every MCP facade view.
+
+Authentication accepts, in order: the MCP key, an Open edX JWT bearer (carries
+is_staff/is_superuser), or a session. Authorization is the single live
+IsStaffOrSuperuser gate. These platform auth classes only import inside a running
+LMS/CMS, which is the only place these URL configs are loaded.
+"""
+from rest_framework.views import APIView
+
+from .auth import IsStaffOrSuperuser, MCPKeyAuthentication
+
+
+def _platform_auth_classes():
+    from edx_rest_framework_extensions.auth.jwt.authentication import JwtAuthentication
+    from rest_framework.authentication import SessionAuthentication
+    return [MCPKeyAuthentication, JwtAuthentication, SessionAuthentication]
+
+
+class MCPView(APIView):
+    permission_classes = [IsStaffOrSuperuser]
+
+    def get_authenticators(self):
+        return [cls() for cls in _platform_auth_classes()]

openedx_mcp/api/mcp/cms_urls.py

@@ -0,0 +1,23 @@
+"""CMS (Studio) URL config — mounted at ^api/mcp/cms/ by MCPCmsConfig.
+Only the authoring tools live here; they need the modulestore (CMS-writable)."""
+from django.urls import path
+
+from . import authoring_views as av
+
+app_name = "openedx_mcp_cms"
+
+COURSE_ID = "<path:course_id>"
+
+urlpatterns = [
+    path(f"courses/{COURSE_ID}/outline/", av.CourseOutlineView.as_view(), name="outline"),
+    path("courses/create/", av.CreateCourseView.as_view(), name="create-course"),
+    path("courses/clone/", av.CloneCourseView.as_view(), name="clone-course"),
+    path("courses/delete/", av.DeleteCourseView.as_view(), name="delete-course"),
+    path("courses/settings/", av.UpdateCourseSettingsView.as_view(), name="course-settings"),
+
+    path("blocks/create/", av.CreateBlockView.as_view(), name="create-block"),
+    path("blocks/create-tree/", av.CreateBlockTreeView.as_view(), name="create-block-tree"),
+    path("blocks/update/", av.UpdateBlockView.as_view(), name="update-block"),
+    path("blocks/publish/", av.PublishBlockView.as_view(), name="publish-block"),
+    path("blocks/delete/", av.DeleteBlockView.as_view(), name="delete-block"),
+]

openedx_mcp/api/mcp/guards.py

@@ -0,0 +1,196 @@
+"""
+Safety rails for state-changing MCP tools.
+
+An MCP key is driven by an autonomous agent, not a human clicking a button. The
+failure mode designed against is a *looping* agent — a retry storm that mass-
+enrols or deletes. Four rails, applied by the `audited_write` decorator:
+
+ 1. Live authority re-check (the IsStaffOrSuperuser permission already does this
+    per request; audited_write assumes it ran).
+ 2. Rate limit — per (key, tool) fixed window. Turns a runaway loop into ~N calls.
+ 3. Confirm token — a write with no token performs a DRY RUN and returns a preview
+    plus a single-use token bound to a fingerprint of the exact payload. Re-send
+    with the token to apply. Changing the payload invalidates the token.
+ 4. Append-only audit — intent recorded before the write; the write is refused if
+    the record cannot be persisted.
+
+The confirm-token store and rate-limit counter use the ambient Django cache. In
+production that must be a shared backend (Redis/memcached); under LocMemCache
+(dev) both are per-process.
+"""
+import functools
+import hashlib
+import json
+import logging
+import secrets
+import time
+
+from django.core.cache import cache
+from rest_framework import status
+from rest_framework.response import Response
+
+from ...models import MCPAuditLog
+from .auth import get_key, require_scopes
+
+log = logging.getLogger(__name__)
+
+CONFIRM_TOKEN_TTL_SECONDS = 300
+_CONFIRM_PREFIX = "mcp:confirm:"
+_RL_PREFIX = "mcp:rl:"
+
+# Per-(key, tool) fixed-window limits: (max_calls, window_seconds). Tuned to the
+# blast radius of one call — mass tools get the tightest budget.
+RATE_LIMITS = {
+    "enroll_user": (60, 60),
+    "unenroll_user": (60, 60),
+    "bulk_enroll": (5, 300),
+    "create_user": (20, 300),
+    "set_role": (30, 60),
+    "deactivate_user": (10, 300),
+    "create_course": (10, 300),
+    "clone_course": (5, 600),
+    "delete_course": (5, 600),
+    "create_xblock": (200, 60),
+    "update_xblock": (200, 60),
+    "publish_xblock": (100, 60),
+    "delete_xblock": (60, 60),
+    "update_course_settings": (60, 60),
+}
+DEFAULT_RATE_LIMIT = (30, 60)
+
+_SENSITIVE = {"confirm_token", "password", "key", "secret", "token"}
+_MAX_LIST_SAMPLE = 20
+
+
+def _fingerprint(tool, user_id, payload):
+    blob = json.dumps({"tool": tool, "user": str(user_id), "payload": payload},
+                      sort_keys=True, default=str)
+    return hashlib.sha256(blob.encode("utf-8")).hexdigest()
+
+
+def issue_confirm_token(tool, user_id, payload):
+    token = secrets.token_urlsafe(24)
+    cache.set(f"{_CONFIRM_PREFIX}{token}", _fingerprint(tool, user_id, payload),
+              CONFIRM_TOKEN_TTL_SECONDS)
+    return token
+
+
+def consume_confirm_token(token, tool, user_id, payload):
+    if not token:
+        return False
+    ck = f"{_CONFIRM_PREFIX}{token}"
+    stored = cache.get(ck)
+    if not stored or stored != _fingerprint(tool, user_id, payload):
+        return False
+    cache.delete(ck)  # single use
+    return True
+
+
+def check_rate_limit(tool, key_id):
+    """Fixed-window counter per (key, tool). Fails OPEN on cache errors."""
+    limit, window = RATE_LIMITS.get(tool, DEFAULT_RATE_LIMIT)
+    try:
+        window_start = int(time.time()) // window
+        ck = f"{_RL_PREFIX}{key_id}:{tool}:{window_start}"
+        cache.add(ck, 0, window)
+        try:
+            count = cache.incr(ck)
+        except ValueError:
+            cache.set(ck, 1, window)
+            count = 1
+        return (count <= limit), window
+    except Exception as exc:  # noqa: BLE001 — fail open, audit is the real guard
+        log.warning("rate-limit check failed tool=%s key=%s: %s", tool, key_id, exc)
+        return True, 0
+
+
+def _redact(payload):
+    out = {}
+    for k, v in (payload or {}).items():
+        if k.lower() in _SENSITIVE:
+            out[k] = "[redacted]"
+        elif isinstance(v, list):
+            out[k] = {"count": len(v), "sample": [str(x)[:200] for x in v[:_MAX_LIST_SAMPLE]],
+                      "truncated": len(v) > _MAX_LIST_SAMPLE}
+        elif isinstance(v, dict):
+            out[k] = _redact(v)
+        elif isinstance(v, str):
+            out[k] = v[:500]
+        else:
+            out[k] = v
+    return out
+
+
+def _unpack(result):
+    if isinstance(result, tuple):
+        return result[0], result[1]
+    return result, 0
+
+
+def audited_write(tool, scope="", require_confirm=True):
+    """Wrap a DRF view method with the write rails.
+
+    The wrapped method is called as `method(self, request, *args, confirmed=bool,
+    **kwargs)` and must return a Response or `(Response, affected_count)`. When
+    `confirmed` is False it MUST NOT write — return a preview of what *would*
+    happen. With require_confirm=False the method is always called confirmed=True.
+    """
+    def decorator(view_method):
+        @functools.wraps(view_method)
+        def wrapper(self, request, *args, **kwargs):
+            if scope:
+                require_scopes(request, scope)  # raises PermissionDenied on miss
+
+            key = get_key(request)
+            key_id = key.pk if key else None
+            user_id = request.user.id
+            payload = request.data if isinstance(request.data, dict) else {}
+            plan = {k: v for k, v in payload.items() if k != "confirm_token"}
+            summary = _redact(plan)
+
+            def _audit(outcome, affected=0, error=""):
+                MCPAuditLog.objects.create(
+                    key=key, user=request.user, tool=tool, scope=scope,
+                    outcome=outcome, request_summary=summary,
+                    affected_count=affected, error=error[:2000],
+                )
+
+            allowed, window = check_rate_limit(tool, key_id or user_id)
+            if not allowed:
+                _audit("denied", error="rate limited")
+                limit, _ = RATE_LIMITS.get(tool, DEFAULT_RATE_LIMIT)
+                return Response(
+                    {"error": "Rate limit exceeded for this tool.",
+                     "limit": limit, "window_seconds": window},
+                    status=status.HTTP_429_TOO_MANY_REQUESTS,
+                )
+
+            if require_confirm:
+                confirmed = consume_confirm_token(payload.get("confirm_token"),
+                                                  tool, user_id, plan)
+                if not confirmed:
+                    _audit("dry_run")
+                    resp, _ = _unpack(view_method(self, request, *args, confirmed=False, **kwargs))
+                    if resp.status_code < 400 and isinstance(resp.data, dict):
+                        resp.data["dry_run"] = True
+                        resp.data["confirm_token"] = issue_confirm_token(tool, user_id, plan)
+                        resp.data["confirm_expires_in_seconds"] = CONFIRM_TOKEN_TTL_SECONDS
+                        resp.data["next_step"] = (
+                            "Re-send the identical request with this confirm_token to apply. "
+                            "Single-use, valid only for this exact payload."
+                        )
+                    return resp
+
+            _audit("attempt")
+            try:
+                result = view_method(self, request, *args, confirmed=True, **kwargs)
+            except Exception as exc:  # noqa: BLE001 — record then re-raise
+                _audit("error", error=str(exc))
+                raise
+            resp, affected = _unpack(result)
+            _audit("success" if resp.status_code < 400 else "error",
+                   affected=affected,
+                   error="" if resp.status_code < 400 else str(getattr(resp, "data", ""))[:500])
+            return resp
+        return wrapper
+    return decorator

openedx_mcp/api/mcp/ops_views.py

@@ -0,0 +1,100 @@
+"""LMS ops endpoints — certificates, async reports (grade export), retirement.
+Reads require staff/superuser; writes add scope + rails via audited_write."""
+from rest_framework.response import Response
+
+from ...models import Scope
+from ...native import certificates as nc
+from ...native import reports as nrep
+from ...native import retirement as nret
+from .base import MCPView
+from .guards import audited_write
+
+
+# --- certificates ---
+
+class UserCertificateView(MCPView):
+    def get(self, request, username, course_id):
+        return Response(nc.get_user_certificate(username, course_id))
+
+
+class UserCertificatesView(MCPView):
+    def get(self, request, username):
+        return Response(nc.list_user_certificates(username))
+
+
+class CourseCertificatesView(MCPView):
+    def get(self, request, course_id):
+        return Response(nc.list_course_certificates(
+            course_id, limit=int(request.query_params.get("limit", 200)),
+            offset=int(request.query_params.get("offset", 0))))
+
+
+class GenerateCertificateView(MCPView):
+    @audited_write("generate_certificate", scope=Scope.WRITE_USERS, require_confirm=False)
+    def post(self, request, confirmed=True):
+        d = request.data
+        # Batch when no username given (whole course / a student_set).
+        if not d.get("username"):
+            return Response(nc.generate_course_certificates(
+                request, d["course_id"], student_set=d.get("student_set"))), 1
+        return Response(nc.generate_user_certificate(d["username"], d["course_id"])), 1
+
+
+class RegenerateCertificatesView(MCPView):
+    @audited_write("generate_certificate", scope=Scope.WRITE_USERS, require_confirm=True)
+    def post(self, request, confirmed=True):
+        d = request.data
+        if not confirmed:
+            return Response({"would_regenerate": d["course_id"], "statuses": d["statuses"]})
+        return Response(nc.regenerate_course_certificates(
+            request, d["course_id"], d["statuses"])), 1
+
+
+class InvalidateCertificateView(MCPView):
+    @audited_write("invalidate_certificate", scope=Scope.DESTRUCTIVE, require_confirm=True)
+    def post(self, request, confirmed=True):
+        d = request.data
+        if not confirmed:
+            return Response({"would_invalidate": d["username"], "course_id": d["course_id"]})
+        return Response(nc.invalidate_certificate(
+            request, d["username"], d["course_id"], notes=d.get("notes", ""))), 1
+
+
+# --- async reports (grade export) ---
+
+class SubmitReportView(MCPView):
+    @audited_write("submit_report", scope=Scope.READ, require_confirm=False)
+    def post(self, request, confirmed=True):
+        d = request.data
+        return Response(nrep.submit_report(
+            request, d["course_id"], kind=d.get("kind", "grades"),
+            features=d.get("features"))), 1
+
+
+class ReportTasksView(MCPView):
+    def get(self, request, course_id):
+        return Response(nrep.list_tasks(course_id))
+
+
+class ReportDownloadsView(MCPView):
+    def get(self, request, course_id):
+        return Response(nrep.list_report_downloads(
+            course_id, config_name=request.query_params.get("config", "GRADES_DOWNLOAD")))
+
+
+# --- account retirement ---
+
+class RetirementStatusView(MCPView):
+    def get(self, request, username):
+        return Response(nret.retirement_status(username))
+
+
+class RequestRetirementView(MCPView):
+    @audited_write("request_retirement", scope=Scope.DESTRUCTIVE, require_confirm=True)
+    def post(self, request, confirmed=True):
+        d = request.data
+        full = d.get("full", True)
+        if not confirmed:
+            return Response({"would_retire": d["username"],
+                             "mode": "full (irreversible, clears PII)" if full else "queue-only"})
+        return Response(nret.request_retirement(d["username"], full=full)), 1