@researai/deepscientist 1.5.9 → 1.5.11

package/src/deepscientist/connector_profiles.py

@@ -1,374 +1 @@
-from __future__ import annotations
-
-from copy import deepcopy
-from typing import Any
-
-from .connector_runtime import infer_connector_transport
-from .shared import slugify
-
-
-PROFILEABLE_CONNECTOR_NAMES = ("telegram", "discord", "slack", "feishu", "whatsapp")
-
-
-def _normalize_secret_pair(payload: dict[str, Any], direct_key: str, env_key: str) -> None:
-    direct = _as_text(payload.get(direct_key))
-    env_name = _as_text(payload.get(env_key))
-    payload[direct_key] = direct
-    payload[env_key] = None if direct else env_name
-
-
-CONNECTOR_PROFILE_SPECS: dict[str, dict[str, Any]] = {
-    "telegram": {
-        "profile_id_prefix": "telegram-profile",
-        "shared_fields": (
-            "enabled",
-            "profiles",
-            "transport",
-            "bot_name",
-            "bot_token",
-            "bot_token_env",
-            "command_prefix",
-            "dm_policy",
-            "allow_from",
-            "group_policy",
-            "group_allow_from",
-            "groups",
-            "require_mention_in_groups",
-            "auto_bind_dm_to_active_quest",
-        ),
-        "profile_defaults": {
-            "profile_id": None,
-            "enabled": True,
-            "transport": "polling",
-            "bot_name": "DeepScientist",
-            "bot_token": None,
-            "bot_token_env": None,
-        },
-        "profile_fields": (
-            "enabled",
-            "transport",
-            "bot_name",
-            "bot_token",
-            "bot_token_env",
-        ),
-        "migration_keys": ("bot_token",),
-        "label_fields": ("bot_name",),
-        "id_fields": ("bot_name",),
-        "secret_pairs": (("bot_token", "bot_token_env"),),
-    },
-    "discord": {
-        "profile_id_prefix": "discord-profile",
-        "shared_fields": (
-            "enabled",
-            "profiles",
-            "transport",
-            "bot_name",
-            "bot_token",
-            "bot_token_env",
-            "command_prefix",
-            "application_id",
-            "dm_policy",
-            "allow_from",
-            "group_policy",
-            "group_allow_from",
-            "groups",
-            "require_mention_in_groups",
-            "auto_bind_dm_to_active_quest",
-            "guild_allowlist",
-        ),
-        "profile_defaults": {
-            "profile_id": None,
-            "enabled": True,
-            "transport": "gateway",
-            "bot_name": "DeepScientist",
-            "bot_token": None,
-            "bot_token_env": None,
-            "application_id": None,
-        },
-        "profile_fields": (
-            "enabled",
-            "transport",
-            "bot_name",
-            "bot_token",
-            "bot_token_env",
-            "application_id",
-        ),
-        "migration_keys": ("bot_token", "application_id"),
-        "label_fields": ("bot_name", "application_id"),
-        "id_fields": ("application_id", "bot_name"),
-        "secret_pairs": (("bot_token", "bot_token_env"),),
-    },
-    "slack": {
-        "profile_id_prefix": "slack-profile",
-        "shared_fields": (
-            "enabled",
-            "profiles",
-            "transport",
-            "bot_name",
-            "bot_token",
-            "bot_token_env",
-            "bot_user_id",
-            "app_token",
-            "app_token_env",
-            "command_prefix",
-            "dm_policy",
-            "allow_from",
-            "group_policy",
-            "group_allow_from",
-            "groups",
-            "require_mention_in_groups",
-            "auto_bind_dm_to_active_quest",
-        ),
-        "profile_defaults": {
-            "profile_id": None,
-            "enabled": True,
-            "transport": "socket_mode",
-            "bot_name": "DeepScientist",
-            "bot_token": None,
-            "bot_token_env": None,
-            "bot_user_id": None,
-            "app_token": None,
-            "app_token_env": None,
-        },
-        "profile_fields": (
-            "enabled",
-            "transport",
-            "bot_name",
-            "bot_token",
-            "bot_token_env",
-            "bot_user_id",
-            "app_token",
-            "app_token_env",
-        ),
-        "migration_keys": ("bot_token", "bot_user_id", "app_token"),
-        "label_fields": ("bot_name", "bot_user_id"),
-        "id_fields": ("bot_user_id", "bot_name"),
-        "secret_pairs": (
-            ("bot_token", "bot_token_env"),
-            ("app_token", "app_token_env"),
-        ),
-    },
-    "feishu": {
-        "profile_id_prefix": "feishu-profile",
-        "shared_fields": (
-            "enabled",
-            "profiles",
-            "transport",
-            "bot_name",
-            "app_id",
-            "app_secret",
-            "app_secret_env",
-            "api_base_url",
-            "command_prefix",
-            "dm_policy",
-            "allow_from",
-            "group_policy",
-            "group_allow_from",
-            "groups",
-            "require_mention_in_groups",
-            "auto_bind_dm_to_active_quest",
-        ),
-        "profile_defaults": {
-            "profile_id": None,
-            "enabled": True,
-            "transport": "long_connection",
-            "bot_name": "DeepScientist",
-            "app_id": None,
-            "app_secret": None,
-            "app_secret_env": None,
-            "api_base_url": "https://open.feishu.cn",
-        },
-        "profile_fields": (
-            "enabled",
-            "transport",
-            "bot_name",
-            "app_id",
-            "app_secret",
-            "app_secret_env",
-            "api_base_url",
-        ),
-        "migration_keys": ("app_id", "app_secret"),
-        "label_fields": ("bot_name", "app_id"),
-        "id_fields": ("app_id", "bot_name"),
-        "secret_pairs": (("app_secret", "app_secret_env"),),
-    },
-    "whatsapp": {
-        "profile_id_prefix": "whatsapp-profile",
-        "shared_fields": (
-            "enabled",
-            "profiles",
-            "transport",
-            "bot_name",
-            "auth_method",
-            "session_dir",
-            "command_prefix",
-            "dm_policy",
-            "allow_from",
-            "group_policy",
-            "group_allow_from",
-            "groups",
-            "auto_bind_dm_to_active_quest",
-        ),
-        "profile_defaults": {
-            "profile_id": None,
-            "enabled": True,
-            "transport": "local_session",
-            "bot_name": "DeepScientist",
-            "auth_method": "qr_browser",
-            "session_dir": "~/.deepscientist/connectors/whatsapp",
-        },
-        "profile_fields": (
-            "enabled",
-            "transport",
-            "bot_name",
-            "auth_method",
-            "session_dir",
-        ),
-        "migration_keys": ("session_dir",),
-        "label_fields": ("bot_name",),
-        "id_fields": ("bot_name",),
-        "secret_pairs": (),
-    },
-}
-
-
-def _as_text(value: Any) -> str | None:
-    text = str(value or "").strip()
-    return text or None
-
-
-def _profile_seed(connector_name: str, raw: dict[str, Any], *, index: int) -> str:
-    spec = CONNECTOR_PROFILE_SPECS[connector_name]
-    explicit = _as_text(raw.get("profile_id"))
-    if explicit:
-        return explicit
-    for key in spec["id_fields"]:
-        candidate = _as_text(raw.get(key))
-        if candidate:
-            return f"{connector_name}-{candidate}"
-    return f"{spec['profile_id_prefix']}-{index:03d}"
-
-
-def _unique_profile_id(seed: str, *, prefix: str, used: set[str]) -> str:
-    base = slugify(seed, default=prefix)
-    candidate = base
-    suffix = 2
-    while candidate in used:
-        candidate = f"{base}-{suffix}"
-        suffix += 1
-    used.add(candidate)
-    return candidate
-
-
-def default_connector_profile(connector_name: str) -> dict[str, Any]:
-    spec = CONNECTOR_PROFILE_SPECS[connector_name]
-    return deepcopy(spec["profile_defaults"])
-
-
-def connector_profile_label(connector_name: str, profile: dict[str, Any] | None) -> str:
-    if not isinstance(profile, dict):
-        return connector_name.capitalize()
-    spec = CONNECTOR_PROFILE_SPECS[connector_name]
-    parts = [_as_text(profile.get(key)) for key in spec["label_fields"]]
-    filtered = [item for item in parts if item]
-    return " · ".join(filtered) if filtered else connector_name.capitalize()
-
-
-def normalize_connector_config(connector_name: str, config: dict[str, Any] | None) -> dict[str, Any]:
-    if connector_name not in CONNECTOR_PROFILE_SPECS:
-        raise KeyError(f"Connector `{connector_name}` does not support generic profile normalization.")
-    spec = CONNECTOR_PROFILE_SPECS[connector_name]
-    payload = deepcopy(config or {})
-    shared = {
-        key: deepcopy(payload.get(key))
-        for key in spec["shared_fields"]
-        if key in payload
-    }
-    shared["profiles"] = []
-    for direct_key, env_key in spec.get("secret_pairs", ()):
-        _normalize_secret_pair(shared, direct_key, env_key)
-
-    raw_profiles = payload.get("profiles")
-    items = list(raw_profiles) if isinstance(raw_profiles, list) else []
-    has_direct_migration_value = any(_as_text(payload.get(key)) for key in spec["migration_keys"])
-    has_env_only_secret = bool(payload.get("enabled")) and any(
-        _as_text(payload.get(env_key))
-        for _, env_key in spec.get("secret_pairs", ())
-    )
-    if not items and (has_direct_migration_value or has_env_only_secret):
-        items = [{key: payload.get(key) for key in spec["profile_fields"]}]
-
-    used_ids: set[str] = set()
-    profiles: list[dict[str, Any]] = []
-    for index, raw in enumerate(items, start=1):
-        if not isinstance(raw, dict):
-            continue
-        current = default_connector_profile(connector_name)
-        for key in ("profile_id", *spec["profile_fields"]):
-            if key in raw:
-                current[key] = deepcopy(raw.get(key))
-        current["enabled"] = bool(current.get("enabled", True))
-        for key in spec["profile_fields"]:
-            if key in {"enabled", "transport", "mode"}:
-                continue
-            if isinstance(current.get(key), list):
-                continue
-            if current.get(key) is None:
-                continue
-            current[key] = _as_text(current.get(key))
-        current["transport"] = infer_connector_transport(connector_name, current)
-        if "mode" in spec["profile_defaults"] or current.get("mode") is not None:
-            current["mode"] = _as_text(current.get("mode")) or str(spec["profile_defaults"].get("mode") or "")
-        for direct_key, env_key in spec.get("secret_pairs", ()):
-            _normalize_secret_pair(current, direct_key, env_key)
-        current["profile_id"] = _unique_profile_id(
-            _profile_seed(connector_name, current, index=index),
-            prefix=str(spec["profile_id_prefix"]),
-            used=used_ids,
-        )
-        profiles.append(current)
-
-    shared["transport"] = infer_connector_transport(connector_name, shared)
-    shared["profiles"] = profiles
-    if len(profiles) == 1:
-        for key in spec["profile_fields"]:
-            shared[key] = profiles[0].get(key)
-    elif len(profiles) > 1:
-        for direct_key, env_key in spec.get("secret_pairs", ()):
-            shared[direct_key] = None
-            shared[env_key] = None
-    return shared
-
-
-def list_connector_profiles(connector_name: str, config: dict[str, Any] | None) -> list[dict[str, Any]]:
-    normalized = normalize_connector_config(connector_name, config)
-    profiles = normalized.get("profiles")
-    return [dict(item) for item in profiles] if isinstance(profiles, list) else []
-
-
-def find_connector_profile(
-    connector_name: str,
-    config: dict[str, Any] | None,
-    *,
-    profile_id: str | None = None,
-) -> dict[str, Any] | None:
-    normalized_profile_id = _as_text(profile_id)
-    for profile in list_connector_profiles(connector_name, config):
-        if normalized_profile_id and str(profile.get("profile_id") or "").strip() == normalized_profile_id:
-            return profile
-    return None
-
-
-def merge_connector_profile_config(
-    connector_name: str,
-    shared_config: dict[str, Any] | None,
-    profile: dict[str, Any],
-) -> dict[str, Any]:
-    normalized = normalize_connector_config(connector_name, shared_config)
-    merged = deepcopy(normalized)
-    merged.pop("profiles", None)
-    for key in CONNECTOR_PROFILE_SPECS[connector_name]["profile_fields"]:
-        merged[key] = profile.get(key)
-    merged["profile_id"] = str(profile.get("profile_id") or "").strip() or None
-    merged["enabled"] = bool(normalized.get("enabled", False)) and bool(profile.get("enabled", True))
-    return merged
+from .connector.connector_profiles import *  # noqa: F401,F403

package/src/deepscientist/connector_runtime.py

@@ -22,6 +22,8 @@ def infer_connector_transport(name: str, config: dict[str, Any] | None) -> str:
 
     if normalized == "qq":
         return "gateway_direct"
+    if normalized == "weixin":
+        return "ilink_long_poll"
     if normalized == "telegram":
         return "polling"
     if normalized == "discord":

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

@@ -77,7 +77,6 @@ class ApiHandlers:
                 "productApis": False,
                 "socketIo": False,
                 "notifications": False,
-                "broadcasts": False,
                 "points": False,
                 "arxiv": True,
                 "cliFrontend": False,
@@ -208,6 +207,20 @@ npm --prefix src/ui run build</pre>
     def connectors_availability(self) -> dict:
         return self.app.connector_availability_summary()
 
+    def weixin_login_qr_start(self, body: dict | None = None) -> dict:
+        payload = body if isinstance(body, dict) else {}
+        return self.app.start_weixin_login_qr(force=bool(payload.get("force")))
+
+    def weixin_login_qr_wait(self, body: dict | None = None) -> dict:
+        payload = body if isinstance(body, dict) else {}
+        return self.app.wait_weixin_login_qr(
+            session_key=str(payload.get("session_key") or "").strip(),
+            timeout_ms=int(payload.get("timeout_ms") or 1_500),
+        )
+
+    def lingzhu_health(self) -> dict:
+        return self.app.lingzhu_health_payload()
+
     def baselines(self) -> list[dict]:
         return self.app.artifact_service.baselines.list_entries()
 
@@ -265,6 +278,18 @@ npm --prefix src/ui run build</pre>
                 "no",
                 "off",
             }
+        auto_bind_latest_connectors_raw = body.get("auto_bind_latest_connectors")
+        if auto_bind_latest_connectors_raw is None:
+            auto_bind_latest_connectors = True
+        else:
+            auto_bind_latest_connectors = bool(auto_bind_latest_connectors_raw) and str(
+                auto_bind_latest_connectors_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
@@ -289,6 +314,7 @@ npm --prefix src/ui run build</pre>
                 preferred_connector_conversation_id=preferred_connector_conversation_id,
                 requested_connector_bindings=requested_connector_bindings,
                 force_connector_rebind=force_connector_rebind,
+                auto_bind_latest_connectors=auto_bind_latest_connectors,
                 requested_baseline_ref=requested_baseline_ref if isinstance(requested_baseline_ref, dict) else None,
                 startup_contract=startup_contract if isinstance(startup_contract, dict) else None,
             )
@@ -416,6 +442,7 @@ npm --prefix src/ui run build</pre>
         }
 
     def quest_bindings(self, quest_id: str, body: dict) -> dict | tuple[int, dict]:
+        previous_external = self.app._quest_external_binding(quest_id)
         requested_bindings = (
             [dict(item) for item in body.get("bindings") if isinstance(item, dict)]
             if isinstance(body.get("bindings"), list)
@@ -426,10 +453,24 @@ npm --prefix src/ui run build</pre>
         force_raw = body.get("force")
         force = bool(force_raw) and str(force_raw).strip().lower() not in {"0", "false", "no", "off"}
         if requested_bindings:
-            return self.app.update_quest_bindings(quest_id, requested_bindings, force=force)
-        if connector_name:
-            return self.app.update_quest_connector_binding(quest_id, connector_name, conversation_id, force=force)
-        return self.app.update_quest_binding(quest_id, conversation_id, force=force)
+            result = self.app.update_quest_bindings(quest_id, requested_bindings, force=force)
+        elif connector_name:
+            result = self.app.update_quest_connector_binding(quest_id, connector_name, conversation_id, force=force)
+        else:
+            result = self.app.update_quest_binding(quest_id, conversation_id, force=force)
+        if isinstance(result, tuple):
+            return result
+        current_external = self.app._quest_external_binding(quest_id)
+        transition = self.app._binding_transition_summary(
+            quest_id=quest_id,
+            previous_conversation_id=previous_external,
+            current_conversation_id=current_external,
+        )
+        self.app._announce_binding_transition(transition, notify_new=True, notify_old=True)
+        return {
+            **result,
+            "binding_transition": transition,
+        }
 
     def quest_session(self, quest_id: str) -> dict:
         snapshot = self.app.quest_service.snapshot_fast(quest_id)
@@ -1113,6 +1154,125 @@ npm --prefix src/ui run build</pre>
     def runs(self, quest_id: str) -> list[dict]:
         return self.app.quest_service.snapshot(quest_id).get("recent_runs", [])
 
+    def arxiv_list(self, path: str = "") -> dict | tuple[int, dict]:
+        query = self.parse_query(path)
+        quest_id = ((query.get("project_id") or [""])[0] or "").strip()
+        if not quest_id:
+            return 400, {"ok": False, "message": "`project_id` is required."}
+        quest_root = self.app.quest_service._quest_root(quest_id)
+        return self.app.artifact_service.arxiv(mode="list", quest_root=quest_root)
+
+    def arxiv_import(self, body: dict | None = None) -> dict | tuple[int, dict]:
+        body = body or {}
+        quest_id = str(body.get("project_id") or "").strip()
+        paper_id = str(body.get("arxiv_id") or "").strip()
+        if not quest_id:
+            return 400, {"ok": False, "message": "`project_id` is required."}
+        if not paper_id:
+            return 400, {"ok": False, "message": "`arxiv_id` is required."}
+        quest_root = self.app.quest_service._quest_root(quest_id)
+        result = self.app.artifact_service.arxiv(
+            paper_id,
+            mode="read",
+            full_text=False,
+            quest_root=quest_root,
+        )
+        if not result.get("ok"):
+            return 400, result
+        return {
+            "status": str(result.get("status") or "processing"),
+            "metadata_status": str(result.get("metadata_status") or ""),
+            "metadata_pending": bool(result.get("metadata_pending")),
+            "title": str(result.get("title") or ""),
+            "message": str(result.get("message") or ""),
+            "abs_url": str(result.get("abs_url") or ""),
+            "file_id": str(result.get("file_id") or ""),
+            "document_id": str(result.get("document_id") or ""),
+            "arxiv_id": str(result.get("paper_id") or paper_id),
+        }
+
+    def annotations_file(self, file_id: str, path: str = "") -> dict | tuple[int, dict]:
+        try:
+            return self.app.annotation_service.list_annotations(file_id)
+        except FileNotFoundError as exc:
+            return 404, {"ok": False, "message": str(exc), "file_id": file_id}
+        except ValueError as exc:
+            return 400, {"ok": False, "message": str(exc), "file_id": file_id}
+
+    def annotations_project(self, project_id: str, path: str = "") -> dict | tuple[int, dict]:
+        query = self.parse_query(path)
+        search_query = ((query.get("q") or [""])[0] or "").strip() or None
+        color = ((query.get("color") or [""])[0] or "").strip() or None
+        tag = ((query.get("tag") or [""])[0] or "").strip() or None
+        page_raw = ((query.get("page") or [""])[0] or "").strip()
+        limit_raw = ((query.get("limit") or ["100"])[0] or "100").strip()
+        try:
+            page = int(page_raw) if page_raw else None
+        except ValueError:
+            page = None
+        try:
+            limit = max(1, min(int(limit_raw), 500))
+        except ValueError:
+            limit = 100
+        try:
+            return self.app.annotation_service.search_annotations(
+                project_id,
+                query=search_query,
+                color=color,
+                tag=tag,
+                page=page,
+                limit=limit,
+            )
+        except FileNotFoundError as exc:
+            return 404, {"ok": False, "message": str(exc), "project_id": project_id}
+
+    def annotation_create(self, body: dict) -> dict | tuple[int, dict]:
+        file_id = str(body.get("file_id") or "").strip()
+        if not file_id:
+            return 400, {"ok": False, "message": "`file_id` is required."}
+        try:
+            return self.app.annotation_service.create_annotation(
+                file_id=file_id,
+                position=body.get("position"),
+                content=body.get("content"),
+                comment=body.get("comment"),
+                kind=body.get("kind"),
+                color=body.get("color"),
+                tags=body.get("tags"),
+            )
+        except FileNotFoundError as exc:
+            return 404, {"ok": False, "message": str(exc), "file_id": file_id}
+        except ValueError as exc:
+            return 400, {"ok": False, "message": str(exc), "file_id": file_id}
+
+    def annotation_detail(self, annotation_id: str) -> dict | tuple[int, dict]:
+        try:
+            return self.app.annotation_service.get_annotation(annotation_id)
+        except FileNotFoundError as exc:
+            return 404, {"ok": False, "message": str(exc), "annotation_id": annotation_id}
+
+    def annotation_update(self, annotation_id: str, body: dict) -> dict | tuple[int, dict]:
+        try:
+            return self.app.annotation_service.update_annotation(
+                annotation_id,
+                comment=body.get("comment") if "comment" in body else None,
+                kind=body.get("kind") if "kind" in body else None,
+                position=body.get("position") if "position" in body else None,
+                content=body.get("content") if "content" in body else None,
+                color=body.get("color") if "color" in body else None,
+                tags=body.get("tags") if "tags" in body else None,
+            )
+        except FileNotFoundError as exc:
+            return 404, {"ok": False, "message": str(exc), "annotation_id": annotation_id}
+        except ValueError as exc:
+            return 400, {"ok": False, "message": str(exc), "annotation_id": annotation_id}
+
+    def annotation_delete(self, annotation_id: str) -> dict | tuple[int, dict]:
+        try:
+            return self.app.annotation_service.delete_annotation(annotation_id)
+        except FileNotFoundError as exc:
+            return 404, {"ok": False, "message": str(exc), "annotation_id": annotation_id}
+
     def quest_memory(self, quest_id: str) -> list[dict]:
         quest_service = self._fresh_quest_service()
         return self._fresh_memory_service().list_cards(

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

@@ -6,7 +6,9 @@ import re
 ROUTES: list[tuple[str, re.Pattern[str], str]] = [
     ("GET", re.compile(r"^/$"), "root"),
     ("GET", re.compile(r"^/ui/(?P<ui_path>.+)$"), "ui_asset"),
-    ("GET", re.compile(r"^/(?P<spa_path>(?!api(?:/|$)|ui(?:/|$)|assets(?:/|$)).+)$"), "spa_root"),
+    ("GET", re.compile(r"^/metis/agent/api/health$"), "lingzhu_health"),
+    ("POST", re.compile(r"^/metis/agent/api/sse$"), "lingzhu_sse"),
+    ("GET", re.compile(r"^/(?P<spa_path>(?!api(?:/|$)|metis(?:/|$)|ui(?:/|$)|assets(?:/|$)).+)$"), "spa_root"),
     ("GET", re.compile(r"^/api/health$"), "health"),
     ("GET", re.compile(r"^/api/system/update$"), "system_update"),
     ("POST", re.compile(r"^/api/system/update$"), "system_update_action"),
@@ -15,6 +17,8 @@ ROUTES: list[tuple[str, re.Pattern[str], str]] = [
     ("GET", re.compile(r"^/api/acp/status$"), "acp_status"),
     ("GET", re.compile(r"^/api/connectors$"), "connectors"),
     ("GET", re.compile(r"^/api/connectors/availability$"), "connectors_availability"),
+    ("POST", re.compile(r"^/api/connectors/weixin/login/qr/start$"), "weixin_login_qr_start"),
+    ("POST", re.compile(r"^/api/connectors/weixin/login/qr/wait$"), "weixin_login_qr_wait"),
     ("GET", re.compile(r"^/api/connectors/qq/bindings$"), "qq_bindings"),
     ("POST", re.compile(r"^/api/connectors/qq/inbound$"), "qq_inbound"),
     ("DELETE", re.compile(r"^/api/connectors/(?P<connector>[^/]+)/profiles/(?P<profile_id>[^/]+)$"), "connector_profile_delete"),
@@ -77,6 +81,14 @@ ROUTES: list[tuple[str, re.Pattern[str], str]] = [
     ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/commands$"), "command"),
     ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/control$"), "quest_control"),
     ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/runs$"), "run_create"),
+    ("GET", re.compile(r"^/api/v1/arxiv/list$"), "arxiv_list"),
+    ("POST", re.compile(r"^/api/v1/arxiv/import$"), "arxiv_import"),
+    ("GET", re.compile(r"^/api/v1/annotations/file/(?P<file_id>.+)$"), "annotations_file"),
+    ("GET", re.compile(r"^/api/v1/annotations/project/(?P<project_id>[^/]+)$"), "annotations_project"),
+    ("POST", re.compile(r"^/api/v1/annotations/?$"), "annotation_create"),
+    ("GET", re.compile(r"^/api/v1/annotations/(?P<annotation_id>[^/]+)$"), "annotation_detail"),
+    ("PATCH", re.compile(r"^/api/v1/annotations/(?P<annotation_id>[^/]+)$"), "annotation_update"),
+    ("DELETE", re.compile(r"^/api/v1/annotations/(?P<annotation_id>[^/]+)$"), "annotation_delete"),
     ("POST", re.compile(r"^/api/v1/projects/(?P<project_id>[^/]+)/latex/init$"), "latex_init"),
     ("POST", re.compile(r"^/api/v1/projects/(?P<project_id>[^/]+)/latex/(?P<folder_id>[^/]+)/compile$"), "latex_compile"),
     ("GET", re.compile(r"^/api/v1/projects/(?P<project_id>[^/]+)/latex/(?P<folder_id>[^/]+)/builds$"), "latex_builds"),