@researai/deepscientist 1.5.7 → 1.5.9

package/src/deepscientist/daemon/api/handlers.py

@@ -14,7 +14,7 @@ from ... import __version__ as DEEPSCIENTIST_VERSION
 from ...gitops import commit_detail, compare_refs, diff_file_between_refs, diff_file_for_commit, export_git_graph, list_branch_canvas, log_ref_history
 from ...memory import MemoryService
 from ...quest import QuestService
-from ...shared import generate_id, read_text, resolve_within, sha256_text, utc_now
+from ...shared import generate_id, read_json, read_text, resolve_within, run_command, sha256_text, utc_now
 from ...runners import RunRequest
 
 
@@ -171,9 +171,9 @@ npm --prefix src/ui run build</pre>
 
     def cli_health(self) -> dict:
         online_channels = [
-            channel.status()
-            for channel in self.app.channels.values()
-            if channel.status().get("enabled") is not False
+            snapshot
+            for snapshot in self.app.list_connector_statuses()
+            if snapshot.get("enabled") is not False
         ]
         return {
             "status": "ok",
@@ -211,6 +211,14 @@ npm --prefix src/ui run build</pre>
     def baselines(self) -> list[dict]:
         return self.app.artifact_service.baselines.list_entries()
 
+    def baseline_delete(self, baseline_id: str) -> dict | tuple[int, dict]:
+        try:
+            return self.app.artifact_service.delete_baseline(baseline_id)
+        except FileNotFoundError as exc:
+            return 404, {"ok": False, "message": str(exc), "baseline_id": baseline_id}
+        except ValueError as exc:
+            return 400, {"ok": False, "message": str(exc), "baseline_id": baseline_id}
+
     def qq_bindings(self) -> list[dict]:
         return self.app.list_qq_bindings()
 
@@ -248,12 +256,15 @@ npm --prefix src/ui run build</pre>
             else []
         )
         force_connector_rebind_raw = body.get("force_connector_rebind")
-        force_connector_rebind = bool(force_connector_rebind_raw) and str(force_connector_rebind_raw).strip().lower() not in {
-            "0",
-            "false",
-            "no",
-            "off",
-        }
+        if force_connector_rebind_raw is None:
+            force_connector_rebind = True
+        else:
+            force_connector_rebind = bool(force_connector_rebind_raw) and str(force_connector_rebind_raw).strip().lower() not in {
+                "0",
+                "false",
+                "no",
+                "off",
+            }
         requested_baseline_ref = body.get("requested_baseline_ref")
         startup_contract = body.get("startup_contract")
         auto_start = body.get("auto_start") is True
@@ -645,8 +656,6 @@ npm --prefix src/ui run build</pre>
             session = self.app.bash_exec_service.get_session(quest_root, session_id)
         except FileNotFoundError:
             return 404, {"ok": False, "message": f"Unknown terminal session `{session_id}`."}
-        if str(session.get("kind") or "").lower() != "terminal":
-            return 400, {"ok": False, "message": "not_terminal_session"}
         if str(session.get("status") or "").lower() in {"completed", "failed", "terminated"}:
             return 409, {"ok": False, "message": "terminal_session_inactive", "session": session}
         try:
@@ -720,6 +729,28 @@ npm --prefix src/ui run build</pre>
     def workflow(self, quest_id: str) -> dict:
         return self.app.quest_service.workflow(quest_id)
 
+    def quest_layout(self, quest_id: str) -> dict:
+        quest_root = self._fresh_quest_service()._quest_root(quest_id)
+        payload = self.app.quest_service.read_lab_canvas_state(quest_root)
+        return {
+            "layout_json": payload.get("layout_json") if isinstance(payload.get("layout_json"), dict) else {},
+            "updated_at": payload.get("updated_at"),
+        }
+
+    def quest_layout_update(self, quest_id: str, body: dict) -> dict | tuple[int, dict]:
+        quest_root = self._fresh_quest_service()._quest_root(quest_id)
+        raw_layout = body.get("layout_json")
+        if raw_layout is not None and not isinstance(raw_layout, dict):
+            return 400, {"ok": False, "message": "`layout_json` must be an object."}
+        payload = self.app.quest_service.update_lab_canvas_state(
+            quest_root,
+            layout_json=dict(raw_layout or {}),
+        )
+        return {
+            "layout_json": payload.get("layout_json") if isinstance(payload.get("layout_json"), dict) else {},
+            "updated_at": payload.get("updated_at"),
+        }
+
     def node_traces(self, quest_id: str, path: str) -> dict:
         query = self.parse_query(path)
         selection_type = ((query.get("selection_type") or [""])[0] or "").strip() or None
@@ -747,6 +778,20 @@ npm --prefix src/ui run build</pre>
     def git_branches(self, quest_id: str) -> dict:
         quest_root = self._fresh_quest_service()._quest_root(quest_id)
         payload = list_branch_canvas(quest_root, quest_id=quest_id)
+        research_state = self.app.quest_service.read_research_state(quest_root)
+        active_workspace_branch = str(research_state.get("current_workspace_branch") or "").strip() or None
+        research_head_branch = str(research_state.get("research_head_branch") or "").strip() or None
+        payload["active_workspace_ref"] = active_workspace_branch
+        payload["research_head_ref"] = research_head_branch
+        payload["workspace_mode"] = str(research_state.get("workspace_mode") or "quest").strip() or "quest"
+        quest_data = self.app.quest_service.read_quest_yaml(quest_root)
+        active_anchor = str(quest_data.get("active_anchor") or "").strip().lower()
+        active_analysis_campaign_id = str(research_state.get("active_analysis_campaign_id") or "").strip() or None
+        current_workspace_branch = str(research_state.get("current_workspace_branch") or "").strip() or None
+        workspace_mode = str(research_state.get("workspace_mode") or "").strip().lower() or "quest"
+        paper_parent_branch = str(research_state.get("paper_parent_branch") or "").strip() or None
+        paper_parent_run_id = str(research_state.get("paper_parent_run_id") or "").strip() or None
+        next_pending_slice_id = str(research_state.get("next_pending_slice_id") or "").strip() or None
         try:
             branch_summary = self.app.artifact_service.list_research_branches(quest_root)
         except Exception:
@@ -756,11 +801,104 @@ npm --prefix src/ui run build</pre>
             for item in (branch_summary.get("branches") or [])
             if str(item.get("branch_name") or "").strip()
         }
+        active_campaign = {}
+        if active_analysis_campaign_id:
+            try:
+                active_campaign = self.app.artifact_service.get_analysis_campaign(
+                    quest_root,
+                    campaign_id=active_analysis_campaign_id,
+                )
+            except Exception:
+                active_campaign = {}
+        campaign_parent_branch = (
+            str(active_campaign.get("parent_branch") or "").strip() or None
+            if isinstance(active_campaign, dict)
+            else None
+        )
+        campaign_slices = [
+            dict(item)
+            for item in ((active_campaign or {}).get("slices") or [])
+            if isinstance(item, dict)
+        ]
+        campaign_total_slices = len(campaign_slices)
+        campaign_completed_slices = sum(
+            1 for item in campaign_slices if str(item.get("status") or "").strip().lower() == "completed"
+        )
+        slice_by_branch = {
+            str(item.get("branch") or "").strip(): item
+            for item in campaign_slices
+            if str(item.get("branch") or "").strip()
+        }
+
+        def resolve_workflow_state(ref: str, summary: dict[str, object] | None) -> dict[str, object]:
+            branch_kind = self.app.artifact_service._branch_kind_from_name(ref)
+            has_main_result = bool((summary or {}).get("has_main_result"))
+            workflow_state: dict[str, object] = {
+                "analysis_state": "none",
+                "writing_state": "not_ready",
+                "analysis_campaign_id": active_analysis_campaign_id,
+                "total_slices": campaign_total_slices or None,
+                "completed_slices": campaign_completed_slices or None,
+                "next_pending_slice_id": next_pending_slice_id,
+                "paper_parent_branch": paper_parent_branch,
+                "paper_parent_run_id": paper_parent_run_id,
+                "status_reason": None,
+            }
+            if branch_kind == "analysis":
+                slice_entry = slice_by_branch.get(ref)
+                slice_status = str((slice_entry or {}).get("status") or "pending").strip().lower() or "pending"
+                if slice_status == "completed":
+                    workflow_state["analysis_state"] = "completed"
+                    workflow_state["status_reason"] = "Analysis slice completed."
+                elif ref == current_workspace_branch or str((slice_entry or {}).get("slice_id") or "").strip() == next_pending_slice_id:
+                    workflow_state["analysis_state"] = "active"
+                    workflow_state["status_reason"] = (
+                        f"Analysis {campaign_completed_slices}/{campaign_total_slices} done"
+                        if campaign_total_slices
+                        else "Analysis slice active."
+                    )
+                else:
+                    workflow_state["analysis_state"] = "pending"
+                    workflow_state["status_reason"] = "Analysis slice pending."
+                return workflow_state
+            if branch_kind == "paper":
+                if ref == current_workspace_branch and workspace_mode == "paper":
+                    workflow_state["writing_state"] = "completed" if active_anchor == "finalize" else "active"
+                    workflow_state["status_reason"] = (
+                        "Writing finalized." if active_anchor == "finalize" else "Writing workspace active."
+                    )
+                else:
+                    workflow_state["writing_state"] = "ready"
+                    workflow_state["status_reason"] = "Writing workspace prepared."
+                return workflow_state
+            if campaign_parent_branch and ref == campaign_parent_branch:
+                workflow_state["analysis_state"] = "completed" if next_pending_slice_id is None else "active"
+                if has_main_result:
+                    workflow_state["writing_state"] = "ready" if next_pending_slice_id is None else "blocked_by_analysis"
+                workflow_state["status_reason"] = (
+                    "Analysis complete. Ready for writing."
+                    if next_pending_slice_id is None
+                    else (
+                        f"Analysis {campaign_completed_slices}/{campaign_total_slices} done"
+                        + (f" · next: {next_pending_slice_id}" if next_pending_slice_id else "")
+                    )
+                )
+                return workflow_state
+            if has_main_result:
+                workflow_state["writing_state"] = "ready"
+                workflow_state["status_reason"] = "Main experiment recorded. Ready for writing."
+                return workflow_state
+            workflow_state["status_reason"] = "Awaiting main experiment result."
+            return workflow_state
+
         for node in payload.get("nodes", []):
             ref = str(node.get("ref") or "").strip()
             if not ref:
                 continue
             summary = branch_summary_by_name.get(ref)
+            node["active_workspace"] = ref == active_workspace_branch
+            node["research_head"] = ref == research_head_branch
+            node["workflow_state"] = resolve_workflow_state(ref, summary if isinstance(summary, dict) else None)
             if not isinstance(summary, dict):
                 continue
             node["branch_no"] = summary.get("branch_no")
@@ -775,6 +913,7 @@ npm --prefix src/ui run build</pre>
             node["idea_draft_path"] = summary.get("idea_draft_path")
             node["latest_main_experiment"] = summary.get("latest_main_experiment")
             node["experiment_count"] = summary.get("experiment_count")
+            node["has_main_result"] = summary.get("has_main_result")
         return payload
 
     def git_log(self, quest_id: str, path: str) -> dict:
@@ -818,6 +957,126 @@ npm --prefix src/ui run build</pre>
         quest_root = self._fresh_quest_service()._quest_root(quest_id)
         return diff_file_between_refs(quest_root, base=base, head=head, path=file_path)
 
+    def file_change_diff(self, quest_id: str, path: str) -> dict:
+        query = self.parse_query(path)
+        run_id = ((query.get("run_id") or [""])[0] or "").strip()
+        event_id = ((query.get("event_id") or [""])[0] or "").strip() or None
+        raw_path = ((query.get("path") or [""])[0] or "").strip()
+        if not run_id or not raw_path:
+            return self._file_change_diff_unavailable(
+                raw_path=raw_path,
+                run_id=run_id or None,
+                event_id=event_id,
+                message="`run_id` and `path` are required.",
+                ok=False,
+            )
+
+        quest_root = self._fresh_quest_service()._quest_root(quest_id)
+        run_artifact = read_json(quest_root / ".ds" / "runs" / run_id / "artifact.json", default={})
+        if not isinstance(run_artifact, dict):
+            return self._file_change_diff_unavailable(
+                raw_path=raw_path,
+                run_id=run_id,
+                event_id=event_id,
+                message="Historical patch unavailable. Run artifact metadata is missing.",
+                ok=False,
+            )
+
+        record = run_artifact.get("record") if isinstance(run_artifact.get("record"), dict) else {}
+        checkpoint = run_artifact.get("checkpoint") if isinstance(run_artifact.get("checkpoint"), dict) else {}
+        base = str(record.get("head_commit") or "").strip()
+        head = str(checkpoint.get("head") or "").strip()
+        branch = str(record.get("branch") or "").strip() or None
+        workspace_root = self._file_change_workspace_root(run_artifact, record)
+        relative_path = None
+        display_path = None
+
+        if not base or not head:
+            relative_path = self._relative_file_change_path(None, raw_path, workspace_root)
+            display_path = self._display_file_change_path(quest_root, raw_path, relative_path=relative_path)
+            return self._file_change_diff_unavailable(
+                raw_path=raw_path,
+                run_id=run_id,
+                event_id=event_id,
+                base=base,
+                head=head,
+                branch=branch,
+                relative_path=relative_path,
+                display_path=display_path,
+                message="Historical patch unavailable. Run artifact metadata is missing the recorded commit range.",
+                ok=True,
+            )
+
+        repo_root = self._resolve_git_repo_root_for_file_change(raw_path, workspace_root)
+        relative_path = self._relative_file_change_path(repo_root, raw_path, workspace_root)
+        display_path = self._display_file_change_path(quest_root, raw_path, relative_path=relative_path)
+
+        if repo_root is None or not relative_path:
+            return self._file_change_diff_unavailable(
+                raw_path=raw_path,
+                run_id=run_id,
+                event_id=event_id,
+                base=base,
+                head=head,
+                branch=branch,
+                relative_path=relative_path,
+                display_path=display_path,
+                message="Historical patch unavailable. DeepScientist could not map this file to a git worktree.",
+                ok=True,
+            )
+
+        try:
+            diff = diff_file_between_refs(repo_root, base=base, head=head, path=relative_path)
+        except Exception:
+            return self._file_change_diff_unavailable(
+                raw_path=raw_path,
+                run_id=run_id,
+                event_id=event_id,
+                base=base,
+                head=head,
+                branch=branch,
+                relative_path=relative_path,
+                display_path=display_path,
+                message=(
+                    "Historical patch unavailable. The saved run checkpoint does not match the git repository "
+                    "that currently owns this file."
+                ),
+                ok=True,
+            )
+
+        if (
+            not diff.get("binary")
+            and not diff.get("lines")
+            and int(diff.get("added") or 0) == 0
+            and int(diff.get("removed") or 0) == 0
+        ):
+            return self._file_change_diff_unavailable(
+                raw_path=raw_path,
+                run_id=run_id,
+                event_id=event_id,
+                base=base,
+                head=head,
+                branch=branch,
+                relative_path=relative_path,
+                display_path=display_path,
+                message=(
+                    "Historical patch unavailable. This event only preserved file-level metadata or the edit "
+                    "did not land in the run's final checkpoint."
+                ),
+                ok=True,
+            )
+
+        return {
+            **diff,
+            "available": True,
+            "source": "run_range",
+            "display_path": display_path or relative_path,
+            "run_id": run_id,
+            "event_id": event_id,
+            "branch": branch,
+            "message": None,
+        }
+
     def git_commit_file(self, quest_id: str, path: str) -> dict:
         query = self.parse_query(path)
         sha = ((query.get("sha") or [""])[0] or "").strip()
@@ -1207,6 +1466,16 @@ npm --prefix src/ui run build</pre>
                 "ok": False,
                 "message": str(exc),
             }
+        raw_reasoning_effort = (
+            body.get("model_reasoning_effort")
+            if "model_reasoning_effort" in body
+            else runner_cfg.get("model_reasoning_effort")
+        )
+        reasoning_effort = (
+            str(raw_reasoning_effort).strip()
+            if raw_reasoning_effort is not None and str(raw_reasoning_effort).strip()
+            else ("xhigh" if raw_reasoning_effort is None else None)
+        )
         request = RunRequest(
             quest_id=quest_id,
             quest_root=quest_root,
@@ -1218,8 +1487,7 @@ npm --prefix src/ui run build</pre>
             approval_policy=runner_cfg.get("approval_policy", "on-request"),
             sandbox_mode=runner_cfg.get("sandbox_mode", "workspace-write"),
             turn_reason=body.get("turn_reason") or "user_message",
-            reasoning_effort=body.get("model_reasoning_effort")
-            or runner_cfg.get("model_reasoning_effort", "xhigh"),
+            reasoning_effort=reasoning_effort,
         )
         result = runner.run(request)
         if result.output_text:
@@ -1355,6 +1623,8 @@ npm --prefix src/ui run build</pre>
             result = self.app.config_manager.save_named_payload(name, body["structured"])
         else:
             result = self.app.config_manager.save_named_text(name, body.get("content", ""))
+        if result.get("ok") and name == "config":
+            result["runtime_reload"] = self.app.reload_runtime_config()
         if result.get("ok") and name == "connectors":
             result["runtime_reload"] = self.app.reload_connectors_config()
         if result.get("ok") and name == "runners":
@@ -1411,6 +1681,136 @@ npm --prefix src/ui run build</pre>
             return {}
         return json.loads(raw.decode("utf-8"))
 
+    @staticmethod
+    def _file_change_workspace_root(run_artifact: dict, record: dict) -> Path | None:
+        workspace_root = str(run_artifact.get("workspace_root") or record.get("workspace_root") or "").strip()
+        if not workspace_root:
+            return None
+        return Path(workspace_root).expanduser()
+
+    @staticmethod
+    def _file_change_path_candidates(raw_path: str, workspace_root: Path | None) -> list[Path]:
+        text = str(raw_path or "").strip()
+        if not text:
+            return []
+        raw_candidate = Path(text).expanduser()
+        candidates: list[Path] = []
+        if raw_candidate.is_absolute():
+            candidates.append(raw_candidate)
+        elif workspace_root is not None:
+            candidates.append(workspace_root / raw_candidate)
+        else:
+            candidates.append(raw_candidate)
+        if workspace_root is not None:
+            candidates.append(workspace_root)
+
+        resolved: list[Path] = []
+        seen: set[str] = set()
+        for candidate in candidates:
+            for variant in (candidate, candidate.resolve(strict=False)):
+                key = str(variant)
+                if key in seen:
+                    continue
+                seen.add(key)
+                resolved.append(variant)
+        return resolved
+
+    @staticmethod
+    def _git_probe_root(candidate: Path) -> Path:
+        if candidate.exists():
+            return candidate if candidate.is_dir() else candidate.parent
+        for parent in candidate.parents:
+            if parent.exists():
+                return parent
+        return candidate.parent
+
+    def _resolve_git_repo_root_for_file_change(self, raw_path: str, workspace_root: Path | None) -> Path | None:
+        for candidate in self._file_change_path_candidates(raw_path, workspace_root):
+            probe_root = self._git_probe_root(candidate)
+            if not str(probe_root).strip():
+                continue
+            result = run_command(["git", "rev-parse", "--show-toplevel"], cwd=probe_root, check=False)
+            if result.returncode != 0:
+                continue
+            top_level = result.stdout.strip()
+            if top_level:
+                return Path(top_level).resolve()
+        return None
+
+    def _relative_file_change_path(self, repo_root: Path | None, raw_path: str, workspace_root: Path | None) -> str | None:
+        if repo_root is None:
+            if Path(str(raw_path or "").strip()).is_absolute():
+                return None
+            normalized = str(raw_path or "").strip().replace("\\", "/").lstrip("/")
+            return normalized or None
+
+        repo_root_resolved = repo_root.resolve()
+        for candidate in self._file_change_path_candidates(raw_path, workspace_root):
+            try:
+                return candidate.relative_to(repo_root_resolved).as_posix()
+            except ValueError:
+                continue
+        if Path(str(raw_path or "").strip()).is_absolute():
+            return None
+        normalized = str(raw_path or "").strip().replace("\\", "/").lstrip("/")
+        return normalized or None
+
+    @staticmethod
+    def _display_file_change_path(quest_root: Path, raw_path: str, *, relative_path: str | None = None) -> str:
+        quest_root_resolved = quest_root.resolve()
+        for candidate in [Path(str(raw_path or "").strip()).expanduser()]:
+            for variant in (candidate, candidate.resolve(strict=False)):
+                try:
+                    relative = variant.relative_to(quest_root_resolved)
+                except ValueError:
+                    continue
+                parts = relative.parts
+                if len(parts) >= 3 and parts[0] == ".ds" and parts[1] == "worktrees":
+                    branch_root = parts[2]
+                    remainder = Path(*parts[3:]).as_posix() if len(parts) > 3 else ""
+                    return f"{branch_root}/{remainder}" if remainder else branch_root
+                return relative.as_posix()
+        if relative_path:
+            return relative_path
+        text = str(raw_path or "").strip()
+        return Path(text).name or text
+
+    @staticmethod
+    def _file_change_diff_unavailable(
+        *,
+        raw_path: str,
+        run_id: str | None,
+        event_id: str | None,
+        message: str,
+        ok: bool,
+        base: str = "",
+        head: str = "",
+        branch: str | None = None,
+        relative_path: str | None = None,
+        display_path: str | None = None,
+    ) -> dict:
+        normalized_path = relative_path or str(raw_path or "").strip()
+        return {
+            "ok": ok,
+            "available": False,
+            "source": "unavailable",
+            "run_id": run_id,
+            "event_id": event_id,
+            "branch": branch,
+            "display_path": display_path or normalized_path,
+            "base": base,
+            "head": head,
+            "path": normalized_path,
+            "old_path": None,
+            "status": "modified",
+            "binary": False,
+            "added": 0,
+            "removed": 0,
+            "lines": [],
+            "truncated": False,
+            "message": message,
+        }
+
     @staticmethod
     def _markdown_title(path: Path) -> str:
         content = read_text(path)

package/src/deepscientist/daemon/api/router.py

@@ -21,6 +21,7 @@ ROUTES: list[tuple[str, re.Pattern[str], str]] = [
     ("GET", re.compile(r"^/api/connectors/(?P<connector>[^/]+)/bindings$"), "connector_bindings"),
     ("POST", re.compile(r"^/api/connectors/(?P<connector>[^/]+)/inbound$"), "connector_inbound"),
     ("GET", re.compile(r"^/api/baselines$"), "baselines"),
+    ("DELETE", re.compile(r"^/api/baselines/(?P<baseline_id>[^/]+)$"), "baseline_delete"),
     ("GET", re.compile(r"^/api/quests$"), "quests"),
     ("GET", re.compile(r"^/api/quest-id/next$"), "quest_next_id"),
     ("POST", re.compile(r"^/api/quests$"), "quest_create"),
@@ -35,6 +36,8 @@ ROUTES: list[tuple[str, re.Pattern[str], str]] = [
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/events$"), "quest_events"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/artifacts$"), "quest_artifacts"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/workflow$"), "workflow"),
+    ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/layout$"), "quest_layout"),
+    ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/layout$"), "quest_layout_update"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/node-traces$"), "node_traces"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/node-traces/(?P<node_ref>.+)$"), "node_trace"),
     ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/stage-view$"), "stage_view"),
@@ -60,6 +63,7 @@ ROUTES: list[tuple[str, re.Pattern[str], str]] = [
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/commit$"), "git_commit"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/diff-file$"), "git_diff_file"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/commit-file$"), "git_commit_file"),
+    ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/operations/file-change-diff$"), "file_change_diff"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/runs$"), "runs"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/memory$"), "quest_memory"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/documents$"), "documents"),