@researai/deepscientist 1.5.9 → 1.5.11

package/src/deepscientist/doctor.py

@@ -265,7 +265,8 @@ def _check_codex(config_manager: ConfigManager) -> dict[str, Any]:
             errors=[f"Runner binary `{binary}` could not be resolved."],
             guidance=[
                 "Run `npm install -g @researai/deepscientist` again so the bundled Codex dependency is installed.",
-                "Then run `codex` once and complete login.",
+                "If `codex` is still missing, install it explicitly with `npm install -g @openai/codex`.",
+                "Then run `codex --login` (or `codex`) once and complete login.",
             ],
             details={"binary": binary},
         )
@@ -285,7 +286,9 @@ def _check_codex(config_manager: ConfigManager) -> dict[str, Any]:
             details={"resolved_binary": resolved_binary},
         )
     if not probe_guidance:
-        probe_guidance = ["Run `codex` manually once and complete login, then retry `ds doctor`."]
+        probe_guidance = [
+            "Run `codex --login` (or `codex`) manually once and complete login, then retry `ds doctor`.",
+        ]
     return _make_check(
         check_id="codex",
         label="Codex CLI",

package/src/deepscientist/gitops/diff.py

@@ -299,45 +299,41 @@ def _collect_branch_state(repo: Path) -> dict[str, dict[str, Any]]:
             continue
         state = branch_state[branch_name]
         state.setdefault("branch", branch_name)
-        state["updated_at"] = record.get("updated_at") or state.get("updated_at")
-        if record.get("kind") == "run":
-            state["run_id"] = record.get("run_id") or state.get("run_id")
-            state["run_kind"] = record.get("run_kind") or state.get("run_kind")
+        artifact_sort_key = _artifact_record_sort_key(record, path)
+        current_artifact_sort_key = state.get("_latest_artifact_sort_key")
+        if current_artifact_sort_key is None or artifact_sort_key > current_artifact_sort_key:
+            state["_latest_artifact_sort_key"] = artifact_sort_key
+            state["updated_at"] = record.get("updated_at") or record.get("created_at") or state.get("updated_at")
         if record.get("idea_id"):
             state["idea_id"] = record.get("idea_id")
         if record.get("parent_branch"):
             state["parent_branch"] = record.get("parent_branch")
         if record.get("worktree_root"):
             state["worktree_root"] = record.get("worktree_root")
-        latest_metric = extract_latest_metric(record)
+        resolved_run_result = _resolve_run_result_payload(repo, record)
+        latest_metric = extract_latest_metric(resolved_run_result if record.get("kind") == "run" else record)
         if latest_metric is not None:
             state["latest_metric"] = latest_metric
         if record.get("kind") == "run":
-            state["latest_result"] = {
-                "run_id": record.get("run_id"),
-                "run_kind": record.get("run_kind"),
-                "status": record.get("status"),
-                "summary": record.get("summary") or record.get("reason"),
-                "verdict": record.get("verdict"),
-                "paths": record.get("paths") or {},
-                "details": record.get("details") or {},
-                "metrics_summary": record.get("metrics_summary") or {},
-                "metric_rows": record.get("metric_rows") or [],
-                "metric_contract": record.get("metric_contract") or {},
-                "baseline_ref": record.get("baseline_ref") or {},
-                "baseline_comparisons": record.get("baseline_comparisons") or {},
-                "progress_eval": record.get("progress_eval") or {},
-                "evaluation_summary": record.get("evaluation_summary")
-                or ((record.get("details") or {}) if isinstance(record.get("details"), dict) else {}).get("evaluation_summary")
-                or {},
-                "files_changed": record.get("files_changed") or [],
-                "evidence_paths": record.get("evidence_paths") or [],
-                "updated_at": record.get("updated_at"),
-            }
-            state["breakthrough"] = bool(((record.get("progress_eval") or {}).get("breakthrough")))
-            state["breakthrough_level"] = ((record.get("progress_eval") or {}).get("breakthrough_level"))
+            candidate_sort_key = _run_result_sort_key(record, resolved_run_result, path)
+            current_sort_key = state.get("_latest_result_sort_key")
+            if current_sort_key is None or candidate_sort_key > current_sort_key:
+                state["_latest_result_sort_key"] = candidate_sort_key
+                state["latest_result"] = resolved_run_result
+                state["run_id"] = resolved_run_result.get("run_id") or state.get("run_id")
+                state["run_kind"] = resolved_run_result.get("run_kind") or state.get("run_kind")
+                progress_eval = (
+                    resolved_run_result.get("progress_eval")
+                    if isinstance(resolved_run_result.get("progress_eval"), dict)
+                    else {}
+                )
+                state["breakthrough"] = bool(progress_eval.get("breakthrough"))
+                state["breakthrough_level"] = progress_eval.get("breakthrough_level")
         if record.get("summary") or record.get("message") or record.get("reason"):
-            state["latest_summary"] = record.get("summary") or record.get("message") or record.get("reason")
+            current_summary_sort_key = state.get("_latest_summary_sort_key")
+            if current_summary_sort_key is None or artifact_sort_key > current_summary_sort_key:
+                state["_latest_summary_sort_key"] = artifact_sort_key
+                state["latest_summary"] = record.get("summary") or record.get("message") or record.get("reason")
         state["recent_artifacts"].append(
             {
                 "artifact_id": record.get("artifact_id"),
@@ -346,12 +342,107 @@ def _collect_branch_state(repo: Path) -> dict[str, dict[str, Any]]:
                 "reason": record.get("reason"),
                 "updated_at": record.get("updated_at"),
                 "status": record.get("status"),
+                "_sort_key": artifact_sort_key,
             }
         )
+        state["recent_artifacts"].sort(key=lambda item: item.get("_sort_key") or ("", 0, ""))
         state["recent_artifacts"] = state["recent_artifacts"][-4:]
+    for state in branch_state.values():
+        latest_result = state.get("latest_result")
+        if isinstance(latest_result, dict):
+            result_metric = extract_latest_metric(latest_result)
+            if result_metric is not None:
+                state["latest_metric"] = result_metric
+        for item in state.get("recent_artifacts", []):
+            if isinstance(item, dict):
+                item.pop("_sort_key", None)
     return branch_state
 
 
+def _resolve_run_result_payload(repo: Path, record: dict[str, Any]) -> dict[str, Any]:
+    details = dict(record.get("details") or {}) if isinstance(record.get("details"), dict) else {}
+    paths = dict(record.get("paths") or {}) if isinstance(record.get("paths"), dict) else {}
+    result_payload: dict[str, Any] = {}
+    result_json_path = _resolve_result_json_path(repo, paths.get("result_json"))
+    if result_json_path and result_json_path.exists():
+        loaded = read_json(result_json_path, {})
+        if isinstance(loaded, dict):
+            result_payload = loaded
+
+    evaluation_summary = (
+        record.get("evaluation_summary")
+        or details.get("evaluation_summary")
+        or result_payload.get("evaluation_summary")
+        or {}
+    )
+    progress_eval = record.get("progress_eval")
+    if not isinstance(progress_eval, dict):
+        progress_eval = result_payload.get("progress_eval") if isinstance(result_payload.get("progress_eval"), dict) else {}
+
+    return {
+        "run_id": record.get("run_id") or result_payload.get("run_id"),
+        "run_kind": record.get("run_kind") or result_payload.get("run_kind"),
+        "status": record.get("status") or result_payload.get("status"),
+        "summary": record.get("summary") or record.get("reason") or result_payload.get("summary"),
+        "verdict": record.get("verdict") or result_payload.get("verdict"),
+        "paths": paths or (result_payload.get("paths") if isinstance(result_payload.get("paths"), dict) else {}) or {},
+        "details": details,
+        "metrics_summary": record.get("metrics_summary") or result_payload.get("metrics_summary") or {},
+        "metric_rows": record.get("metric_rows") or result_payload.get("metric_rows") or [],
+        "metric_contract": record.get("metric_contract") or result_payload.get("metric_contract") or {},
+        "baseline_ref": record.get("baseline_ref") or result_payload.get("baseline_ref") or {},
+        "baseline_comparisons": record.get("baseline_comparisons") or result_payload.get("baseline_comparisons") or {},
+        "progress_eval": progress_eval or {},
+        "evaluation_summary": evaluation_summary or {},
+        "files_changed": record.get("files_changed") or result_payload.get("files_changed") or [],
+        "evidence_paths": record.get("evidence_paths") or result_payload.get("evidence_paths") or [],
+        "updated_at": record.get("updated_at") or result_payload.get("updated_at"),
+    }
+
+
+def _resolve_result_json_path(repo: Path, raw_path: object) -> Path | None:
+    normalized = str(raw_path or "").strip()
+    if not normalized:
+        return None
+    candidate = Path(normalized).expanduser()
+    if candidate.is_absolute():
+        return candidate
+    return repo / candidate
+
+
+def _artifact_record_sort_key(record: dict[str, Any], path: Path) -> tuple[str, int, str]:
+    updated_at = str(record.get("updated_at") or record.get("created_at") or "").strip()
+    try:
+        mtime_ns = path.stat().st_mtime_ns
+    except OSError:
+        mtime_ns = 0
+    return (updated_at, mtime_ns, str(path))
+
+
+def _run_result_sort_key(record: dict[str, Any], payload: dict[str, Any], path: Path) -> tuple[int, str, int, str]:
+    quality = 0
+    if extract_latest_metric(payload):
+        quality += 8
+    if payload.get("baseline_comparisons"):
+        quality += 4
+    if payload.get("progress_eval"):
+        quality += 4
+    if payload.get("metrics_summary"):
+        quality += 3
+    if payload.get("metric_rows"):
+        quality += 3
+    if payload.get("verdict"):
+        quality += 2
+    paths = payload.get("paths") if isinstance(payload.get("paths"), dict) else {}
+    if paths.get("result_json"):
+        quality += 2
+    if paths.get("run_md"):
+        quality += 1
+    updated_at = str(payload.get("updated_at") or record.get("updated_at") or record.get("created_at") or "")
+    _, mtime_ns, path_str = _artifact_record_sort_key(record, path)
+    return (quality, updated_at, mtime_ns, path_str)
+
+
 def _classify_ref(ref: str, state: dict[str, Any]) -> dict[str, str]:
     run_id = str(state.get("run_id") or "")
     run_kind = str(state.get("run_kind") or "")

package/src/deepscientist/lingzhu_support.py

@@ -1,182 +1 @@
-from __future__ import annotations
-
-import json
-import secrets
-from typing import Any
-from urllib.parse import urlparse
-
-
-DEFAULT_LINGZHU_GATEWAY_PORT = 18789
-DEFAULT_LINGZHU_LOCAL_HOST = "127.0.0.1"
-DEFAULT_LINGZHU_AGENT_ID = "main"
-DEFAULT_LINGZHU_SESSION_NAMESPACE = "lingzhu"
-
-_AUTH_AK_SEGMENTS = (8, 4, 4, 4, 12)
-_AUTH_AK_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789"
-
-
-def generate_lingzhu_auth_ak() -> str:
-    parts: list[str] = []
-    for segment_length in _AUTH_AK_SEGMENTS:
-        parts.append("".join(secrets.choice(_AUTH_AK_CHARS) for _ in range(segment_length)))
-    return "-".join(parts)
-
-
-def lingzhu_local_host(config: dict[str, Any] | None) -> str:
-    value = str((config or {}).get("local_host") or DEFAULT_LINGZHU_LOCAL_HOST).strip()
-    return value or DEFAULT_LINGZHU_LOCAL_HOST
-
-
-def lingzhu_gateway_port(config: dict[str, Any] | None) -> int:
-    raw = (config or {}).get("gateway_port")
-    try:
-        value = int(raw)
-    except (TypeError, ValueError):
-        return DEFAULT_LINGZHU_GATEWAY_PORT
-    if value < 1 or value > 65535:
-        return DEFAULT_LINGZHU_GATEWAY_PORT
-    return value
-
-
-def normalize_public_base_url(value: Any) -> str | None:
-    text = str(value or "").strip()
-    if not text:
-        return None
-    parsed = urlparse(text)
-    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
-        return None
-    return text.rstrip("/")
-
-
-def lingzhu_local_base_url(config: dict[str, Any] | None) -> str:
-    return f"http://{lingzhu_local_host(config)}:{lingzhu_gateway_port(config)}"
-
-
-def lingzhu_public_base_url(config: dict[str, Any] | None) -> str | None:
-    return normalize_public_base_url((config or {}).get("public_base_url"))
-
-
-def lingzhu_health_url(config: dict[str, Any] | None, *, public: bool = False) -> str | None:
-    base = lingzhu_public_base_url(config) if public else lingzhu_local_base_url(config)
-    if not base:
-        return None
-    return f"{base}/metis/agent/api/health"
-
-
-def lingzhu_sse_url(config: dict[str, Any] | None, *, public: bool = False) -> str | None:
-    base = lingzhu_public_base_url(config) if public else lingzhu_local_base_url(config)
-    if not base:
-        return None
-    return f"{base}/metis/agent/api/sse"
-
-
-def lingzhu_agent_id(config: dict[str, Any] | None) -> str:
-    value = str((config or {}).get("agent_id") or DEFAULT_LINGZHU_AGENT_ID).strip()
-    return value or DEFAULT_LINGZHU_AGENT_ID
-
-
-def lingzhu_probe_payload(
-    config: dict[str, Any] | None,
-    *,
-    message_id: str = "ds-lingzhu-probe-001",
-    text: str = "你好",
-) -> dict[str, Any]:
-    return {
-        "message_id": message_id,
-        "agent_id": lingzhu_agent_id(config),
-        "message": [
-            {
-                "role": "user",
-                "type": "text",
-                "text": text,
-            }
-        ],
-    }
-
-
-def lingzhu_generated_openclaw_config(config: dict[str, Any] | None) -> dict[str, Any]:
-    resolved = dict(config or {})
-    return {
-        "gateway": {
-            "port": lingzhu_gateway_port(resolved),
-            "http": {
-                "endpoints": {
-                    "chatCompletions": {
-                        "enabled": True,
-                    }
-                }
-            },
-        },
-        "plugins": {
-            "entries": {
-                "lingzhu": {
-                    "enabled": bool(resolved.get("enabled", False)),
-                    "config": {
-                        "authAk": str(resolved.get("auth_ak") or "").strip(),
-                        "agentId": lingzhu_agent_id(resolved),
-                        "includeMetadata": bool(resolved.get("include_metadata", True)),
-                        "requestTimeoutMs": int(resolved.get("request_timeout_ms") or 60000),
-                        "systemPrompt": str(resolved.get("system_prompt") or ""),
-                        "defaultNavigationMode": str(resolved.get("default_navigation_mode") or "0"),
-                        "enableFollowUp": bool(resolved.get("enable_follow_up", True)),
-                        "followUpMaxCount": int(resolved.get("follow_up_max_count") or 3),
-                        "maxImageBytes": int(resolved.get("max_image_bytes") or 5 * 1024 * 1024),
-                        "sessionMode": str(resolved.get("session_mode") or "per_user"),
-                        "sessionNamespace": str(
-                            resolved.get("session_namespace") or DEFAULT_LINGZHU_SESSION_NAMESPACE
-                        ),
-                        "autoReceiptAck": bool(resolved.get("auto_receipt_ack", True)),
-                        "visibleProgressHeartbeat": bool(
-                            resolved.get("visible_progress_heartbeat", True)
-                        ),
-                        "visibleProgressHeartbeatSec": int(
-                            resolved.get("visible_progress_heartbeat_sec") or 10
-                        ),
-                        "debugLogging": bool(resolved.get("debug_logging", False)),
-                        "debugLogPayloads": bool(resolved.get("debug_log_payloads", False)),
-                        "debugLogDir": str(resolved.get("debug_log_dir") or ""),
-                        "enableExperimentalNativeActions": bool(
-                            resolved.get("enable_experimental_native_actions", False)
-                        ),
-                    },
-                }
-            }
-        },
-    }
-
-
-def lingzhu_generated_openclaw_config_text(config: dict[str, Any] | None) -> str:
-    return json.dumps(lingzhu_generated_openclaw_config(config), indent=2, ensure_ascii=False)
-
-
-def lingzhu_generated_curl(config: dict[str, Any] | None, *, text: str = "你好") -> str:
-    auth_ak = str((config or {}).get("auth_ak") or "").strip()
-    payload = lingzhu_probe_payload(config, text=text)
-    endpoint_url = lingzhu_sse_url(config) or ""
-    return (
-        f"curl -X POST '{endpoint_url}' \\\n"
-        f"  --header 'Authorization: Bearer {auth_ak}' \\\n"
-        "  --header 'Content-Type: application/json' \\\n"
-        f"  --data '{json.dumps(payload, ensure_ascii=False)}'"
-    )
-
-
-def lingzhu_supported_commands(*, experimental_enabled: bool) -> list[str]:
-    commands = [
-        "take_photo",
-        "take_navigation",
-        "control_calendar",
-        "notify_agent_off",
-    ]
-    if experimental_enabled:
-        commands.extend(
-            [
-                "send_notification",
-                "send_toast",
-                "speak_tts",
-                "start_video_record",
-                "stop_video_record",
-                "open_custom_view",
-            ]
-        )
-    return commands
+from .connector.lingzhu_support import *  # noqa: F401,F403

package/src/deepscientist/mcp/server.py

@@ -680,16 +680,23 @@ def build_artifact_server(context: McpContext) -> FastMCP:
     @server.tool(
         name="arxiv",
         description=(
-            "Read an identified arXiv paper by id. "
-            "Use full_text=false for the overview/abstract path and full_text=true when the full paper body is needed."
+            "Interact with the quest-local arXiv library. "
+            "Use mode='read' to read one paper by id with local-first automatic persistence, "
+            "or mode='list' to list the saved arXiv items for the current quest."
         ),
     )
     def arxiv(
-        paper_id: str,
+        paper_id: str | None = None,
+        mode: str = "read",
         full_text: bool = False,
         comment: str | dict[str, Any] | None = None,
     ) -> dict[str, Any]:
-        return service.arxiv(paper_id, full_text=full_text)
+        return service.arxiv(
+            paper_id,
+            mode=mode,
+            full_text=full_text,
+            quest_root=context.require_quest_root(),
+        )
 
     @server.tool(name="refresh_summary", description="Refresh SUMMARY.md from recent artifact state.")
     def refresh_summary(

package/src/deepscientist/prompts/builder.py

@@ -283,6 +283,21 @@ class PromptBuilder:
                     "- qq_structured_delivery_rule: when you want native QQ markdown or native QQ image/file delivery, request it through artifact.interact(connector_hints=..., attachments=[...]) instead of inventing connector-specific inline tag syntax.",
                 ]
             )
+        elif connector == "weixin":
+            lines.extend(
+                [
+                    "- weixin_surface_rule: Weixin is a concise operator surface, not a full artifact browser.",
+                    "- weixin_default_mode: keep outbound replies concise, respectful, text-first, and progress-aware.",
+                    "- weixin_length_rule: for ordinary Weixin progress replies, normally use only 2 to 4 short sentences, or 3 very short bullets at most.",
+                    "- weixin_summary_first_rule: start with the user-facing conclusion, then the immediate meaning, then the next action.",
+                    "- weixin_progress_shape_rule: make the current task, the main difficulty or latest real progress, and the next concrete next step explicit whenever possible.",
+                    "- weixin_eta_rule: for important long-running phases, include a rough ETA or next check-in window when it is helpful and defensible.",
+                    "- weixin_internal_detail_rule: do not proactively dump file inventories, path lists, retry counters, or monitor-log style telemetry unless the user asked for them or they explain a real risk.",
+                    "- weixin_context_token_rule: reply continuity is managed by the runtime through `context_token`; do not invent your own reply token scheme.",
+                    "- weixin_media_rule: when you want native Weixin image, video, or file delivery, request it through artifact.interact(..., attachments=[...]) with `connector_delivery={'weixin': {'media_kind': ...}}` instead of inventing connector-specific inline tag syntax.",
+                    "- weixin_inbound_media_rule: inbound Weixin image, video, and file messages can arrive as quest-local attachments under `userfiles/weixin/...`; read those files when the user sent media.",
+                ]
+            )
         else:
             lines.append("- connector_media_rule: if the active surface is not QQ, keep using the general artifact interaction discipline for milestone delivery.")
 

package/src/deepscientist/qq_profiles.py

@@ -1,196 +1 @@
-from __future__ import annotations
-
-from copy import deepcopy
-from typing import Any
-
-from .shared import slugify
-
-
-QQ_PROFILE_ID_PREFIX = "qq-profile"
-def default_qq_profile() -> dict[str, Any]:
-    return {
-        "profile_id": None,
-        "enabled": True,
-        "app_id": None,
-        "app_secret": None,
-        "app_secret_env": None,
-        "bot_name": "DeepScientist",
-        "main_chat_id": None,
-    }
-
-
-def _as_text(value: Any) -> str | None:
-    text = str(value or "").strip()
-    return text or None
-
-
-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
-
-
-def _profile_id_seed(*, profile_id: Any, app_id: Any, bot_name: Any, index: int) -> str:
-    explicit = _as_text(profile_id)
-    if explicit:
-        return explicit
-    app_text = _as_text(app_id)
-    if app_text:
-        return f"qq-{app_text}"
-    bot_text = slugify(str(bot_name or "").strip(), default="")
-    if bot_text:
-        return f"{QQ_PROFILE_ID_PREFIX}-{bot_text}"
-    return f"{QQ_PROFILE_ID_PREFIX}-{index:03d}"
-
-
-def _unique_profile_id(seed: str, *, used: set[str]) -> str:
-    base = slugify(seed, default=QQ_PROFILE_ID_PREFIX)
-    candidate = base
-    suffix = 2
-    while candidate in used:
-        candidate = f"{base}-{suffix}"
-        suffix += 1
-    used.add(candidate)
-    return candidate
-
-
-def list_qq_profiles(config: dict[str, Any] | None) -> list[dict[str, Any]]:
-    normalized = normalize_qq_connector_config(config)
-    profiles = normalized.get("profiles")
-    return [dict(item) for item in profiles] if isinstance(profiles, list) else []
-
-
-def find_qq_profile(
-    config: dict[str, Any] | None,
-    *,
-    profile_id: str | None = None,
-    app_id: str | None = None,
-) -> dict[str, Any] | None:
-    normalized_profile_id = _as_text(profile_id)
-    normalized_app_id = _as_text(app_id)
-    for profile in list_qq_profiles(config):
-        if normalized_profile_id and str(profile.get("profile_id") or "").strip() == normalized_profile_id:
-            return profile
-        if normalized_app_id and str(profile.get("app_id") or "").strip() == normalized_app_id:
-            return profile
-    return None
-
-
-def merge_qq_profile_config(shared_config: dict[str, Any] | None, profile: dict[str, Any]) -> dict[str, Any]:
-    normalized = normalize_qq_connector_config(shared_config)
-    merged = deepcopy(normalized)
-    merged.pop("profiles", None)
-    app_secret = _as_text(profile.get("app_secret"))
-    app_secret_env = _as_text(profile.get("app_secret_env"))
-    merged.update(
-        {
-            "profile_id": str(profile.get("profile_id") or "").strip() or None,
-            "app_id": _as_text(profile.get("app_id")),
-            "app_secret": app_secret,
-            "app_secret_env": None if app_secret else app_secret_env,
-            "bot_name": _as_text(profile.get("bot_name")) or str(normalized.get("bot_name") or "DeepScientist"),
-            "main_chat_id": _as_text(profile.get("main_chat_id")),
-            "enabled": bool(normalized.get("enabled", False)) and bool(profile.get("enabled", True)),
-            "transport": "gateway_direct",
-        }
-    )
-    return merged
-
-
-def qq_profile_label(profile: dict[str, Any] | None) -> str:
-    if not isinstance(profile, dict):
-        return "QQ"
-    bot_name = _as_text(profile.get("bot_name"))
-    app_id = _as_text(profile.get("app_id"))
-    if bot_name and app_id:
-        return f"{bot_name} · {app_id}"
-    if bot_name:
-        return bot_name
-    if app_id:
-        return f"QQ · {app_id}"
-    return "QQ"
-
-
-def normalize_qq_connector_config(config: dict[str, Any] | None) -> dict[str, Any]:
-    payload = deepcopy(config or {})
-    shared_defaults = {
-        "enabled": False,
-        "transport": "gateway_direct",
-        "app_id": None,
-        "app_secret": None,
-        "app_secret_env": None,
-        "bot_name": "DeepScientist",
-        "command_prefix": "/",
-        "main_chat_id": None,
-        "require_at_in_groups": True,
-        "auto_bind_dm_to_active_quest": True,
-        "gateway_restart_on_config_change": True,
-        "auto_send_main_experiment_png": True,
-        "auto_send_analysis_summary_png": True,
-        "auto_send_slice_png": True,
-        "auto_send_paper_pdf": True,
-        "enable_markdown_send": False,
-        "enable_file_upload_experimental": False,
-        "profiles": [],
-    }
-    shared = {**shared_defaults, **payload}
-    shared["transport"] = "gateway_direct"
-    shared["command_prefix"] = _as_text(shared.get("command_prefix")) or "/"
-    shared["bot_name"] = _as_text(shared.get("bot_name")) or "DeepScientist"
-    _normalize_secret_pair(shared, "app_secret", "app_secret_env")
-
-    raw_profiles = payload.get("profiles")
-    items = list(raw_profiles) if isinstance(raw_profiles, list) else []
-    legacy_profile_seed = {
-        "app_id": payload.get("app_id"),
-        "app_secret": payload.get("app_secret"),
-        "app_secret_env": payload.get("app_secret_env"),
-        "bot_name": payload.get("bot_name"),
-        "main_chat_id": payload.get("main_chat_id"),
-    }
-    if not items:
-        has_direct_profile_seed = any(_as_text(legacy_profile_seed.get(key)) for key in ("app_id", "app_secret", "main_chat_id"))
-        has_env_profile_seed = bool(payload.get("enabled")) and bool(_as_text(legacy_profile_seed.get("app_secret_env")))
-        if has_direct_profile_seed or has_env_profile_seed:
-            items = [legacy_profile_seed]
-
-    profiles: list[dict[str, Any]] = []
-    used_ids: set[str] = set()
-    for index, raw in enumerate(items, start=1):
-        if not isinstance(raw, dict):
-            continue
-        current = {**default_qq_profile(), **raw}
-        current["enabled"] = bool(current.get("enabled", True))
-        current["app_id"] = _as_text(current.get("app_id"))
-        current["app_secret"] = _as_text(current.get("app_secret"))
-        current["app_secret_env"] = _as_text(current.get("app_secret_env")) or shared["app_secret_env"]
-        _normalize_secret_pair(current, "app_secret", "app_secret_env")
-        current["bot_name"] = _as_text(current.get("bot_name")) or shared["bot_name"]
-        current["main_chat_id"] = _as_text(current.get("main_chat_id"))
-        current["profile_id"] = _unique_profile_id(
-            _profile_id_seed(
-                profile_id=current.get("profile_id"),
-                app_id=current.get("app_id"),
-                bot_name=current.get("bot_name"),
-                index=index,
-            ),
-            used=used_ids,
-        )
-        profiles.append(current)
-
-    shared["profiles"] = profiles
-    if len(profiles) == 1:
-        mirror = profiles[0]
-        shared["app_id"] = mirror.get("app_id")
-        shared["app_secret"] = mirror.get("app_secret")
-        shared["app_secret_env"] = mirror.get("app_secret_env")
-        shared["bot_name"] = mirror.get("bot_name")
-        shared["main_chat_id"] = mirror.get("main_chat_id")
-    else:
-        shared["app_id"] = None
-        shared["app_secret"] = None
-        shared["app_secret_env"] = None
-        shared["main_chat_id"] = None
-
-    return shared
+from .connector.qq_profiles import *  # noqa: F401,F403