@researai/deepscientist 1.5.14 → 1.5.16

package/src/deepscientist/bridges/connectors.py

@@ -18,8 +18,11 @@ from ..connector.weixin_support import (
     WEIXIN_UPLOAD_MEDIA_FILE,
     WEIXIN_UPLOAD_MEDIA_IMAGE,
     WEIXIN_UPLOAD_MEDIA_VIDEO,
+    clear_weixin_context_send_state,
     download_weixin_remote_attachment,
+    get_weixin_context_entry,
     get_weixin_context_token,
+    mark_weixin_context_stale,
     normalize_weixin_base_url,
     normalize_weixin_cdn_base_url,
     send_weixin_message,
@@ -558,10 +561,11 @@ class QQConnectorBridge(BaseConnectorBridge):
             connector_delivery = item.get("connector_delivery") if isinstance(item.get("connector_delivery"), dict) else {}
             qq_delivery = connector_delivery.get("qq") if isinstance(connector_delivery.get("qq"), dict) else {}
             media_kind = str(qq_delivery.get("media_kind") or "").strip().lower()
+            allow_internal_auto_media = bool(qq_delivery.get("allow_internal_auto_media"))
             if media_kind not in {"image", "file"}:
                 residual_items.append(item)
                 continue
-            if not native_enabled:
+            if not native_enabled and not allow_internal_auto_media:
                 issues.append(
                     {
                         "attachment_index": index,
@@ -781,7 +785,9 @@ class WeixinConnectorBridge(BaseConnectorBridge):
     name = "weixin"
     _MEDIA_ITEM_TYPES = {2, 4, 5}
     _MEDIA_SEND_INITIAL_DELAY_SECONDS = 0.8
-    _MEDIA_SEND_RETRY_DELAYS_SECONDS = (1.5, 3.0)
+    _TEXT_SEND_RETRY_DELAYS_SECONDS = (0.8, 1.5, 3.0)
+    _MEDIA_SEND_RETRY_DELAYS_SECONDS = (1.5, 3.0, 5.0)
+    _STALE_CONTEXT_SUPPRESSED_KINDS = {"progress", "milestone", "assistant", "summary", "ack"}
 
     def deliver(self, payload: dict[str, Any], config: dict[str, Any]) -> dict[str, Any] | None:
         return self.deliver_direct(payload, config)
@@ -800,14 +806,26 @@ class WeixinConnectorBridge(BaseConnectorBridge):
                 "error": "Weixin outbound target is empty.",
             }
         connector_root = self._connector_root(config)
+        kind = str(payload.get("kind") or "").strip().lower()
+        context_entry = get_weixin_context_entry(connector_root, to_user_id)
         context_token = get_weixin_context_token(connector_root, to_user_id)
         if not context_token:
+            if kind in self._STALE_CONTEXT_SUPPRESSED_KINDS:
+                return self._queued_context_wait_response(
+                    reason=f"Weixin context_token is missing for `{to_user_id}`. Waiting for the next inbound message.",
+                )
             return {
                 "ok": False,
                 "queued": False,
                 "transport": "weixin-ilink",
                 "error": f"Weixin context_token is missing for `{to_user_id}`. Wait for one inbound message first.",
             }
+        if bool(context_entry.get("stale_context")) and kind in self._STALE_CONTEXT_SUPPRESSED_KINDS:
+            stale_since = str(context_entry.get("stale_since") or "").strip()
+            warning = "Weixin outbound is paused until the next inbound message refreshes context_token."
+            if stale_since:
+                warning = f"{warning} stale_since={stale_since}"
+            return self._queued_context_wait_response(reason=warning)
 
         native_attachments, residual_attachments, warnings = self._partition_native_attachments(payload.get("attachments"))
         rendered_text = self.render_text(payload.get("text"), residual_attachments)
@@ -895,6 +913,20 @@ class WeixinConnectorBridge(BaseConnectorBridge):
             else:
                 warnings.append("Weixin outbound payload contained neither text nor sendable attachments.")
         except Exception as exc:
+            if "ret=-2" in str(exc or "").lower():
+                mark_weixin_context_stale(
+                    connector_root,
+                    user_id=to_user_id,
+                    error=str(exc),
+                    kind=kind or None,
+                )
+                if kind in self._STALE_CONTEXT_SUPPRESSED_KINDS:
+                    queued = self._queued_context_wait_response(
+                        reason="Weixin send hit stale context and was deferred until the next inbound refresh.",
+                    )
+                    queued["parts"] = parts
+                    queued["warnings"] = [*warnings, *(queued.get("warnings") or [])]
+                    return queued
             return {
                 "ok": False,
                 "queued": False,
@@ -909,6 +941,12 @@ class WeixinConnectorBridge(BaseConnectorBridge):
         error_messages = [str(item.get("error") or "").strip() for item in failed if str(item.get("error") or "").strip()]
         error_messages.extend(warnings)
         last_success = succeeded[-1] if succeeded else {}
+        if succeeded:
+            clear_weixin_context_send_state(
+                connector_root,
+                user_id=to_user_id,
+                kind=kind or None,
+            )
         return {
             "ok": bool(succeeded),
             "queued": False,
@@ -920,6 +958,17 @@ class WeixinConnectorBridge(BaseConnectorBridge):
             "error": "; ".join(error_messages) if error_messages else None,
         }
 
+    @staticmethod
+    def _queued_context_wait_response(*, reason: str) -> dict[str, Any]:
+        return {
+            "ok": False,
+            "queued": True,
+            "transport": "weixin-ilink",
+            "parts": [],
+            "warnings": [str(reason or "").strip()],
+            "error": None,
+        }
+
     @staticmethod
     def _partition_native_attachments(
         attachments: Any,

package/src/deepscientist/cli.py

@@ -25,23 +25,78 @@ from .registries import BaselineRegistry
 from .runners import CodexRunner, RunRequest, get_runner_factory, register_builtin_runners
 from .runtime_tools import RuntimeToolService
 from .runtime_logs import JsonlLogger
-from .shared import ensure_dir, read_yaml
+from .shared import ensure_dir, read_json, read_yaml
 from .skills import SkillInstaller
 from .tui import watch_tui
 
 
+class DeepScientistArgumentParser(argparse.ArgumentParser):
+    def error(self, message: str) -> None:
+        self.print_usage(sys.stderr)
+        self.exit(2, f"DeepScientist argument error: {message}\nRun `{self.prog} --help` for usage.\n")
+
+
 def _local_ui_url(host: str, port: int) -> str:
-    connect_host = "0.0.0.0" if host in {"0.0.0.0", "::", ""} else host
-    return f"http://{connect_host}:{port}"
+    normalized = str(host or "").strip()
+    connect_host = "127.0.0.1" if normalized in {"0.0.0.0", "::", "[::]", ""} else normalized
+    if connect_host.startswith("[") and connect_host.endswith("]"):
+        rendered_host = connect_host
+    elif ":" in connect_host:
+        rendered_host = f"[{connect_host}]"
+    else:
+        rendered_host = connect_host
+    return f"http://{rendered_host}:{port}"
+
+
+def _parse_optional_bool(value: object) -> bool | None:
+    if isinstance(value, bool):
+        return value
+    normalized = str(value or "").strip().lower()
+    if not normalized:
+        return None
+    if normalized in {"1", "true", "yes", "on"}:
+        return True
+    if normalized in {"0", "false", "no", "off"}:
+        return False
+    return None
+
+
+def _daemon_request_headers(home: Path) -> dict[str, str]:
+    headers = {"Content-Type": "application/json"}
+    state = read_json(home / "runtime" / "daemon.json", {})
+    if not isinstance(state, dict):
+        return headers
+    if bool(state.get("auth_enabled")):
+        token = str(state.get("auth_token") or "").strip()
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+    return headers
+
+
+def _daemon_launch_url(home: Path, *, host: str, port: int) -> str:
+    state = read_json(home / "runtime" / "daemon.json", {})
+    if isinstance(state, dict):
+        launch_url = str(state.get("launch_url") or "").strip()
+        if launch_url:
+            return launch_url
+    return _local_ui_url(host, port)
 
 
 def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="ds", description="DeepScientist Core skeleton")
+    parser = DeepScientistArgumentParser(
+        prog="ds",
+        description="DeepScientist Core skeleton",
+        allow_abbrev=False,
+    )
     parser.add_argument("--home", default=None, help="Override DeepScientist home")
     parser.add_argument("--proxy", default=None, help="Explicit outbound HTTP/WS proxy, for example `http://127.0.0.1:7890`.")
     parser.add_argument("--codex", default=None, help="Override the Codex executable path for this invocation.")
 
-    subparsers = parser.add_subparsers(dest="command", required=True)
+    subparsers = parser.add_subparsers(
+        dest="command",
+        required=True,
+        parser_class=DeepScientistArgumentParser,
+    )
 
     subparsers.add_parser("init")
 
@@ -60,12 +115,24 @@ def build_parser() -> argparse.ArgumentParser:
     daemon_parser = subparsers.add_parser("daemon")
     daemon_parser.add_argument("--host", default=None)
     daemon_parser.add_argument("--port", type=int, default=None)
+    daemon_parser.add_argument("--auth", default=None)
+    daemon_parser.add_argument("--auth-token", default=None)
+    daemon_parser.add_argument(
+        "--prompt-version",
+        default=None,
+        help="Use `latest` managed prompts, an official historical prompt version such as `1.5.13`, or an exact backup id from `.codex/prompt_versions/` for this daemon session.",
+    )
 
     run_parser = subparsers.add_parser("run")
     run_parser.add_argument("skill_id")
     run_parser.add_argument("--quest-id", required=True)
     run_parser.add_argument("--message", required=True)
     run_parser.add_argument("--model", default=None)
+    run_parser.add_argument(
+        "--prompt-version",
+        default=None,
+        help="Use `latest` managed prompts, an official historical prompt version such as `1.5.13`, or an exact backup id from `.codex/prompt_versions/` for this one-off run.",
+    )
 
     ui_parser = subparsers.add_parser("ui")
     ui_parser.add_argument("--mode", choices=("web", "tui", "both"), default="web")
@@ -186,7 +253,6 @@ def resume_command(home: Path, quest_id: str) -> int:
     print(json.dumps(snapshot, ensure_ascii=False, indent=2))
     return 0
 
-
 def _daemon_control_quest(home: Path, quest_id: str, *, action: str) -> dict | None:
     config = ConfigManager(home).load_named("config", create_optional=False)
     ui_config = config.get("ui", {})
@@ -194,7 +260,7 @@ def _daemon_control_quest(home: Path, quest_id: str, *, action: str) -> dict | N
     request = Request(
         url,
         data=json.dumps({"action": action, "source": "cli"}).encode("utf-8"),
-        headers={"Content-Type": "application/json"},
+        headers=_daemon_request_headers(home),
         method="POST",
     )
     try:
@@ -211,7 +277,7 @@ def _daemon_create_quest(home: Path, *, goal: str, quest_id: str | None) -> dict
     request = Request(
         url,
         data=json.dumps({"goal": goal, "quest_id": quest_id, "source": "cli"}).encode("utf-8"),
-        headers={"Content-Type": "application/json"},
+        headers=_daemon_request_headers(home),
         method="POST",
     )
     try:
@@ -221,18 +287,37 @@ def _daemon_create_quest(home: Path, *, goal: str, quest_id: str | None) -> dict
         return None
 
 
-def daemon_command(home: Path, host: str | None, port: int | None) -> int:
+def daemon_command(
+    home: Path,
+    host: str | None,
+    port: int | None,
+    auth: str | None,
+    auth_token: str | None,
+    prompt_version: str | None,
+) -> int:
     ensure_home_layout(home)
     config_manager = ConfigManager(home)
     config_manager.ensure_files()
     config = config_manager.load_named("config")
     ui_config = config.get("ui", {})
-    daemon = DaemonApp(home)
+    daemon = DaemonApp(
+        home,
+        browser_auth_enabled=_parse_optional_bool(auth),
+        browser_auth_token=str(auth_token or "").strip() or None,
+        prompt_version_selection=str(prompt_version or "").strip() or None,
+    )
     daemon.serve(host or ui_config.get("host", "0.0.0.0"), port or ui_config.get("port", 20999))
     return 0
 
 
-def run_command(home: Path, quest_id: str, skill_id: str, message: str, model: str | None) -> int:
+def run_command(
+    home: Path,
+    quest_id: str,
+    skill_id: str,
+    message: str,
+    model: str | None,
+    prompt_version: str | None,
+) -> int:
     ensure_home_layout(home)
     config_manager = ConfigManager(home)
     config_manager.ensure_files()
@@ -246,7 +331,11 @@ def run_command(home: Path, quest_id: str, skill_id: str, message: str, model: s
         repo_root=repo_root(),
         binary=codex_cfg.get("binary", "codex"),
         logger=logger,
-        prompt_builder=PromptBuilder(repo_root(), home),
+        prompt_builder=PromptBuilder(
+            repo_root(),
+            home,
+            prompt_version_selection=str(prompt_version or "").strip() or None,
+        ),
         artifact_service=ArtifactService(home),
     )
     register_builtin_runners(codex_runner=runner)
@@ -322,19 +411,26 @@ def launch_ink_tui(home: Path, url: str) -> int:
             )
         )
         return 1
-    return subprocess.call([node_binary, str(entry), "--base-url", url])
+    state = read_json(home / "runtime" / "daemon.json", {})
+    args = [node_binary, str(entry), "--base-url", url]
+    if isinstance(state, dict) and bool(state.get("auth_enabled")):
+        token = str(state.get("auth_token") or "").strip()
+        if token:
+            args.extend(["--auth-token", token])
+    return subprocess.call(args)
 
 
 def ui_command(home: Path, mode: str) -> int:
     config = ConfigManager(home).load_named("config", create_optional=False)
     host = config.get("ui", {}).get("host", "0.0.0.0")
     port = config.get("ui", {}).get("port", 20999)
-    url = _local_ui_url(host, port)
+    base_url = _local_ui_url(str(host), int(port))
+    launch_url = _daemon_launch_url(home, host=str(host), port=int(port))
     if mode in {"web", "both"}:
-        webbrowser.open(url)
-        print(f"Opened {url}")
+        webbrowser.open(launch_url)
+        print(f"Opened {launch_url}")
     if mode in {"tui", "both"}:
-        return launch_ink_tui(home, url)
+        return launch_ink_tui(home, base_url)
     return 0
 
 
@@ -492,9 +588,9 @@ def main(argv: list[str] | None = None) -> int:
     if args.command == "resume":
         return resume_command(home, args.quest_id)
     if args.command == "daemon":
-        return daemon_command(home, args.host, args.port)
+        return daemon_command(home, args.host, args.port, args.auth, args.auth_token, args.prompt_version)
     if args.command == "run":
-        return run_command(home, args.quest_id, args.skill_id, args.message, args.model)
+        return run_command(home, args.quest_id, args.skill_id, args.message, args.model, args.prompt_version)
     if args.command == "ui":
         return ui_command(home, args.mode)
     if args.command == "note":

package/src/deepscientist/codex_cli_compat.py

@@ -2,12 +2,19 @@ from __future__ import annotations
 
 import json
 import re
+import shutil
 import subprocess
 import tomllib
 from functools import lru_cache
+from pathlib import Path
+
+from .shared import ensure_dir, read_text, write_text
 
 _MIN_XHIGH_SUPPORTED_VERSION = (0, 63, 0)
 _CODEX_VERSION_PATTERN = re.compile(r"codex-cli\s+(\d+)\.(\d+)\.(\d+)", re.IGNORECASE)
+_CODEX_HOME_SYNCED_FILES = ("config.toml", "auth.json")
+_CODEX_HOME_SYNCED_DIRS = ("skills", "agents", "prompts")
+_CODEX_HOME_QUEST_OVERLAY_DIRS = ("skills", "prompts")
 
 
 def parse_codex_cli_version(text: str) -> tuple[int, int, int] | None:
@@ -115,3 +122,228 @@ def adapt_profile_only_provider_config(
             f"{', '.join(injected_fields)} to the top level for Codex compatibility."
         ),
     )
+
+
+def _remove_tree_path(path: Path) -> None:
+    if not path.exists() and not path.is_symlink():
+        return
+    if path.is_symlink() or path.is_file():
+        path.unlink()
+        return
+    shutil.rmtree(path)
+
+
+def _overlay_file_sources(*roots: Path) -> dict[Path, Path]:
+    merged: dict[Path, Path] = {}
+    for root in roots:
+        if not root.exists() or not root.is_dir():
+            continue
+        for source_path in sorted(root.rglob("*")):
+            if not source_path.is_file():
+                continue
+            merged[source_path.relative_to(root)] = source_path
+    return merged
+
+
+def _sync_overlay_directory(target_dir: Path, *source_dirs: Path) -> None:
+    desired_files = _overlay_file_sources(*source_dirs)
+    if not desired_files:
+        _remove_tree_path(target_dir)
+        return
+
+    desired_dirs: set[Path] = {Path(".")}
+    for relative in desired_files:
+        parent = relative.parent
+        while True:
+            desired_dirs.add(parent)
+            if parent == Path("."):
+                break
+            parent = parent.parent
+
+    if target_dir.exists() or target_dir.is_symlink():
+        for existing_path in sorted(target_dir.rglob("*"), reverse=True):
+            relative = existing_path.relative_to(target_dir)
+            if existing_path.is_dir() and not existing_path.is_symlink():
+                if relative not in desired_dirs:
+                    shutil.rmtree(existing_path)
+                continue
+            if relative not in desired_files:
+                existing_path.unlink()
+
+    ensure_dir(target_dir)
+    for relative in sorted(desired_dirs, key=lambda item: (len(item.parts), item.as_posix())):
+        if relative == Path("."):
+            continue
+        current = target_dir / relative
+        if current.exists() and (current.is_symlink() or current.is_file()):
+            current.unlink()
+        ensure_dir(current)
+
+    for relative, source_path in desired_files.items():
+        target_path = target_dir / relative
+        if target_path.exists() and target_path.is_dir() and not target_path.is_symlink():
+            shutil.rmtree(target_path)
+        ensure_dir(target_path.parent)
+        try:
+            same_path = source_path.resolve() == target_path.resolve()
+        except FileNotFoundError:
+            same_path = False
+        if same_path:
+            continue
+        shutil.copy2(source_path, target_path)
+
+
+def materialize_codex_runtime_home(
+    *,
+    source_home: str | Path,
+    target_home: str | Path,
+    profile: str = "",
+    quest_codex_root: str | Path | None = None,
+) -> str | None:
+    source_root = Path(source_home).expanduser()
+    target_root = ensure_dir(Path(target_home))
+
+    for filename in _CODEX_HOME_SYNCED_FILES:
+        source_path = source_root / filename
+        target_path = target_root / filename
+        if not source_path.exists():
+            _remove_tree_path(target_path)
+            continue
+        if target_path.exists() and target_path.is_dir() and not target_path.is_symlink():
+            shutil.rmtree(target_path)
+        ensure_dir(target_path.parent)
+        try:
+            same_path = source_path.resolve() == target_path.resolve()
+        except FileNotFoundError:
+            same_path = False
+        if not same_path:
+            shutil.copy2(source_path, target_path)
+
+    overlay_root = Path(quest_codex_root) if quest_codex_root is not None else None
+    for dirname in _CODEX_HOME_SYNCED_DIRS:
+        overlay_dir = overlay_root / dirname if overlay_root is not None and dirname in _CODEX_HOME_QUEST_OVERLAY_DIRS else None
+        source_dirs: list[Path] = [source_root / dirname]
+        if overlay_dir is not None:
+            source_dirs.append(overlay_dir)
+        _sync_overlay_directory(target_root / dirname, *source_dirs)
+
+    warning: str | None = None
+    config_path = target_root / "config.toml"
+    if profile and config_path.exists():
+        adapted_text, warning = adapt_profile_only_provider_config(read_text(config_path), profile=profile)
+        write_text(config_path, adapted_text)
+    return warning
+
+
+def provider_profile_metadata(
+    config_text: str,
+    *,
+    profile: str,
+) -> dict[str, str | bool | None]:
+    normalized_profile = str(profile or "").strip()
+    if not normalized_profile or not str(config_text or "").strip():
+        return {
+            "provider": None,
+            "model": None,
+            "env_key": None,
+            "base_url": None,
+            "wire_api": None,
+            "requires_openai_auth": None,
+        }
+    try:
+        parsed = tomllib.loads(config_text)
+    except tomllib.TOMLDecodeError:
+        return {
+            "provider": None,
+            "model": None,
+            "env_key": None,
+            "base_url": None,
+            "wire_api": None,
+            "requires_openai_auth": None,
+        }
+
+    profiles = parsed.get("profiles")
+    if not isinstance(profiles, dict):
+        return {
+            "provider": None,
+            "model": None,
+            "env_key": None,
+            "base_url": None,
+            "wire_api": None,
+            "requires_openai_auth": None,
+        }
+    profile_payload = profiles.get(normalized_profile)
+    if not isinstance(profile_payload, dict):
+        return {
+            "provider": None,
+            "model": None,
+            "env_key": None,
+            "base_url": None,
+            "wire_api": None,
+            "requires_openai_auth": None,
+        }
+
+    model_provider = str(
+        profile_payload.get("model_provider")
+        or parsed.get("model_provider")
+        or ""
+    ).strip() or None
+    model = str(
+        profile_payload.get("model")
+        or parsed.get("model")
+        or ""
+    ).strip() or None
+    provider_payload = None
+    model_providers = parsed.get("model_providers")
+    if model_provider and isinstance(model_providers, dict):
+        candidate = model_providers.get(model_provider)
+        if isinstance(candidate, dict):
+            provider_payload = candidate
+
+    env_key = (
+        str(provider_payload.get("env_key") or "").strip()
+        if isinstance(provider_payload, dict)
+        else None
+    ) or None
+    base_url = (
+        str(provider_payload.get("base_url") or "").strip()
+        if isinstance(provider_payload, dict)
+        else None
+    ) or None
+    wire_api = (
+        str(provider_payload.get("wire_api") or "").strip()
+        if isinstance(provider_payload, dict)
+        else None
+    ) or None
+    requires_openai_auth = (
+        bool(provider_payload.get("requires_openai_auth"))
+        if isinstance(provider_payload, dict) and "requires_openai_auth" in provider_payload
+        else None
+    )
+
+    return {
+        "provider": model_provider,
+        "model": model,
+        "env_key": env_key,
+        "base_url": base_url,
+        "wire_api": wire_api,
+        "requires_openai_auth": requires_openai_auth,
+    }
+
+
+def provider_profile_metadata_from_home(
+    config_home: str | Path,
+    *,
+    profile: str,
+) -> dict[str, str | bool | None]:
+    config_path = Path(config_home).expanduser() / "config.toml"
+    if not config_path.exists():
+        return {
+            "provider": None,
+            "model": None,
+            "env_key": None,
+            "base_url": None,
+            "wire_api": None,
+            "requires_openai_auth": None,
+        }
+    return provider_profile_metadata(config_path.read_text(encoding="utf-8"), profile=profile)

package/src/deepscientist/config/models.py

@@ -22,7 +22,7 @@ def config_filename(name: str) -> str:
 
 
 def default_system_enabled_connectors() -> dict[str, bool]:
-    return {name: name in {"qq", "weixin", "lingzhu"} for name in SYSTEM_CONNECTOR_NAMES}
+    return {name: name in {"qq", "weixin", "telegram", "feishu", "whatsapp", "lingzhu"} for name in SYSTEM_CONNECTOR_NAMES}
 
 
 def default_config(home: Path) -> dict:
@@ -38,6 +38,7 @@ def default_config(home: Path) -> dict:
         "ui": {
             "host": "0.0.0.0",
             "port": 20999,
+            "auth_enabled": False,
             "auto_open_browser": True,
             "default_mode": "web",
         },
@@ -96,10 +97,10 @@ def default_runners() -> dict:
             "binary": "codex",
             "config_dir": "~/.codex",
             "profile": "",
-            "model": "gpt-5.4",
+            "model": "inherit",
             "model_reasoning_effort": "xhigh",
-            "approval_policy": "on-request",
-            "sandbox_mode": "workspace-write",
+            "approval_policy": "never",
+            "sandbox_mode": "danger-full-access",
             "retry_on_failure": True,
             "retry_max_attempts": 5,
             "retry_initial_backoff_sec": 10.0,
@@ -154,6 +155,9 @@ def default_connectors() -> dict:
             "transport": "ilink_long_poll",
             "bot_name": "DeepScientist",
             "command_prefix": "/",
+            "auto_send_main_experiment_png": True,
+            "stale_replay_latest_limit": 5,
+            "stale_replay_interval_seconds": 2.0,
             "base_url": "https://ilinkai.weixin.qq.com",
             "cdn_base_url": "https://novac2c.cdn.weixin.qq.com/c2c",
             "bot_type": "3",