@researai/deepscientist 1.5.17 → 1.6.0

package/src/deepscientist/channels/weixin_ilink.py

@@ -23,6 +23,13 @@ _SESSION_RETRY_INITIAL_SECONDS = 5.0
 _SESSION_RETRY_MAX_SECONDS = 60.0
 _POLL_RETRY_INITIAL_SECONDS = 2.0
 _POLL_RETRY_MAX_SECONDS = 30.0
+# Hard ceiling on the long-poll timeout we will accept from the iLink server.
+# Without this, a misbehaving server can return an arbitrarily large
+# longpolling_timeout_ms, which then becomes the urlopen() timeout for the
+# next request — and Python's urllib does not always honour socket timeouts
+# during stalled SSL reads, so the polling thread can hang indefinitely and
+# block the daemon scheduler that depends on it.
+_SERVER_LONG_POLL_CEILING_MS = 60_000
 
 
 class WeixinIlinkService:
@@ -152,7 +159,7 @@ class WeixinIlinkService:
                 )
                 long_poll_timeout_ms = int(response.get("longpolling_timeout_ms") or 0)
                 if long_poll_timeout_ms > 0:
-                    timeout_ms = long_poll_timeout_ms
+                    timeout_ms = min(long_poll_timeout_ms, _SERVER_LONG_POLL_CEILING_MS)
                 errcode = int(response.get("errcode") or 0)
                 retcode = int(response.get("ret") or 0)
                 if errcode == SESSION_EXPIRED_ERRCODE or retcode == SESSION_EXPIRED_ERRCODE:

package/src/deepscientist/cli.py

@@ -22,7 +22,7 @@ from .network import configure_runtime_proxy, urlopen_with_proxy as urlopen
 from .prompts import PromptBuilder
 from .quest import QuestService
 from .registries import BaselineRegistry
-from .runners import CodexRunner, RunRequest, get_runner_factory, register_builtin_runners
+from .runners import ClaudeRunner, CodexRunner, KimiRunner, OpenCodeRunner, RunRequest, get_runner_factory, register_builtin_runners
 from .runtime_tools import RuntimeToolService
 from .runtime_logs import JsonlLogger
 from .shared import ensure_dir, read_json, read_yaml
@@ -61,6 +61,19 @@ def _parse_optional_bool(value: object) -> bool | None:
     return None
 
 
+def _normalize_cli_runner_name(value: object, fallback: str = "") -> str:
+    normalized = str(value or "").strip().lower().replace("_", "-")
+    if not normalized:
+        return fallback
+    if normalized in {"claude-code", "claudecode"}:
+        return "claude"
+    if normalized in {"kimi-code", "kimicode"}:
+        return "kimi"
+    if normalized in {"open-code", "open code", "opencode-ai", "opencodeai"}:
+        return "opencode"
+    return normalized.replace("-", "")
+
+
 def _daemon_request_headers(home: Path) -> dict[str, str]:
     headers = {"Content-Type": "application/json"}
     state = read_json(home / "runtime" / "daemon.json", {})
@@ -117,6 +130,7 @@ def build_parser() -> argparse.ArgumentParser:
     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("--runner", default=None, help=argparse.SUPPRESS)
     daemon_parser.add_argument(
         "--prompt-version",
         default=None,
@@ -128,6 +142,7 @@ def build_parser() -> argparse.ArgumentParser:
     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("--runner", default=None)
     run_parser.add_argument(
         "--prompt-version",
         default=None,
@@ -149,7 +164,13 @@ def build_parser() -> argparse.ArgumentParser:
     graph_parser = subparsers.add_parser("graph")
     graph_parser.add_argument("quest_id")
 
-    subparsers.add_parser("doctor", aliases=["docker"])
+    doctor_parser = subparsers.add_parser("doctor", aliases=["docker"])
+    doctor_parser.add_argument(
+        "--runner",
+        action="append",
+        default=None,
+        help="Probe one runner instead of every enabled runner. Can be repeated or comma-separated; use `all` for every built-in runner.",
+    )
 
     push_parser = subparsers.add_parser("push")
     push_parser.add_argument("quest_id")
@@ -294,8 +315,13 @@ def daemon_command(
     auth: str | None,
     auth_token: str | None,
     prompt_version: str | None,
+    runner: str | None = None,
 ) -> int:
     ensure_home_layout(home)
+    normalized_runner = _normalize_cli_runner_name(runner)
+    if normalized_runner:
+        os.environ["DEEPSCIENTIST_DEFAULT_RUNNER"] = normalized_runner
+        os.environ["DEEPSCIENTIST_ENABLE_RUNNER"] = normalized_runner
     config_manager = ConfigManager(home)
     config_manager.ensure_files()
     config = config_manager.load_named("config")
@@ -317,6 +343,7 @@ def run_command(
     message: str,
     model: str | None,
     prompt_version: str | None,
+    runner_override: str | None = None,
 ) -> int:
     ensure_home_layout(home)
     config_manager = ConfigManager(home)
@@ -325,22 +352,70 @@ def run_command(
     runners = config_manager.load_runners_config()
     quest_root = home / "quests" / quest_id
     codex_cfg = runners.get("codex", {})
+    claude_cfg = runners.get("claude", {})
+    kimi_cfg = runners.get("kimi", {})
+    opencode_cfg = runners.get("opencode", {})
     logger = JsonlLogger(home / "logs", level=config.get("logging", {}).get("level", "info"))
-    runner = CodexRunner(
+    prompt_builder = PromptBuilder(
+        repo_root(),
+        home,
+        prompt_version_selection=str(prompt_version or "").strip() or None,
+    )
+    artifact_service = ArtifactService(home)
+    codex_runner = CodexRunner(
         home=home,
         repo_root=repo_root(),
         binary=codex_cfg.get("binary", "codex"),
         logger=logger,
-        prompt_builder=PromptBuilder(
-            repo_root(),
-            home,
-            prompt_version_selection=str(prompt_version or "").strip() or None,
-        ),
-        artifact_service=ArtifactService(home),
+        prompt_builder=prompt_builder,
+        artifact_service=artifact_service,
+    )
+    claude_runner = ClaudeRunner(
+        home=home,
+        repo_root=repo_root(),
+        binary=claude_cfg.get("binary", "claude"),
+        logger=logger,
+        prompt_builder=prompt_builder,
+        artifact_service=artifact_service,
+    )
+    kimi_runner = KimiRunner(
+        home=home,
+        repo_root=repo_root(),
+        binary=kimi_cfg.get("binary", "kimi"),
+        logger=logger,
+        prompt_builder=prompt_builder,
+        artifact_service=artifact_service,
+    )
+    opencode_runner = OpenCodeRunner(
+        home=home,
+        repo_root=repo_root(),
+        binary=opencode_cfg.get("binary", "opencode"),
+        logger=logger,
+        prompt_builder=prompt_builder,
+        artifact_service=artifact_service,
+    )
+    register_builtin_runners(
+        codex_runner=codex_runner,
+        claude_runner=claude_runner,
+        kimi_runner=kimi_runner,
+        opencode_runner=opencode_runner,
     )
-    register_builtin_runners(codex_runner=runner)
-    runner_name = str(config.get("default_runner", "codex")).strip().lower()
-    runner_cfg = runners.get(runner_name, {})
+    explicit_runner = _normalize_cli_runner_name(runner_override)
+    candidate_runners = [explicit_runner, config.get("default_runner", "codex"), "codex"]
+    runner_name = "codex"
+    runner_cfg = {}
+    for candidate in candidate_runners:
+        normalized = _normalize_cli_runner_name(candidate)
+        if not normalized:
+            continue
+        current_cfg = runners.get(normalized, {}) if isinstance(runners.get(normalized), dict) else {}
+        if current_cfg.get("enabled") is False and normalized != explicit_runner:
+            continue
+        runner_name = normalized
+        runner_cfg = dict(current_cfg)
+        if normalized == explicit_runner:
+            runner_cfg["enabled"] = True
+        break
     if runner_cfg.get("enabled") is False:
         print(
             json.dumps(
@@ -464,8 +539,8 @@ def graph_command(home: Path, quest_id: str) -> int:
     return 0
 
 
-def doctor_command(home: Path) -> int:
-    report = run_doctor(home, repo_root=repo_root())
+def doctor_command(home: Path, runner_names: list[str] | None = None) -> int:
+    report = run_doctor(home, repo_root=repo_root(), runner_names=runner_names)
     sys.stdout.write(render_doctor_report(report))
     return 0 if report.get("ok") else 1
 
@@ -588,9 +663,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, args.auth, args.auth_token, args.prompt_version)
+        return daemon_command(home, args.host, args.port, args.auth, args.auth_token, args.prompt_version, args.runner)
     if args.command == "run":
-        return run_command(home, args.quest_id, args.skill_id, args.message, args.model, args.prompt_version)
+        return run_command(home, args.quest_id, args.skill_id, args.message, args.model, args.prompt_version, args.runner)
     if args.command == "ui":
         return ui_command(home, args.mode)
     if args.command == "note":
@@ -600,7 +675,7 @@ def main(argv: list[str] | None = None) -> int:
     if args.command == "graph":
         return graph_command(home, args.quest_id)
     if args.command in {"doctor", "docker"}:
-        return doctor_command(home)
+        return doctor_command(home, args.runner)
     if args.command == "push":
         return push_command(home, args.quest_id)
     if args.command == "memory" and args.memory_command == "search":

package/src/deepscientist/codex_cli_compat.py

@@ -10,7 +10,7 @@ from functools import lru_cache
 from pathlib import Path
 from urllib.parse import urlparse
 
-from .shared import ensure_dir, read_text, write_text
+from .shared import ensure_dir, read_text, utf8_text_subprocess_kwargs, write_text
 
 _MIN_XHIGH_SUPPORTED_VERSION = (0, 63, 0)
 _CHAT_WIRE_COMPAT_VERSION = (0, 57, 0)
@@ -43,8 +43,8 @@ def codex_cli_version(binary: str) -> tuple[int, int, int] | None:
             [normalized, "--version"],
             check=False,
             capture_output=True,
-            text=True,
             timeout=10,
+            **utf8_text_subprocess_kwargs(),
         )
     except (OSError, subprocess.TimeoutExpired):
         return None

package/src/deepscientist/config/models.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from dataclasses import dataclass
 from pathlib import Path
 
+from ..runners.metadata import get_runner_metadata, list_builtin_runner_names
+
 CONFIG_NAMES = ("config", "runners", "connectors", "plugins", "mcp_servers")
 REQUIRED_CONFIG_NAMES = ("config", "runners", "connectors")
 OPTIONAL_CONFIG_NAMES = ("plugins", "mcp_servers")
@@ -47,6 +49,25 @@ def default_config(home: Path) -> dict:
             "console": True,
             "keep_days": 30,
         },
+        "hardware": {
+            "gpu_selection_mode": "all",
+            "selected_gpu_ids": [],
+            "include_system_hardware_in_prompt": False,
+        },
+        "memory": {
+            "read_visibility_mode": "independent",
+        },
+        "literature": {
+            "deepxiv": {
+                "enabled": False,
+                "base_url": "https://data.rag.ac.cn",
+                "token": None,
+                "token_env": "DEEPXIV_TOKEN",
+                "default_result_size": 10,
+                "preview_characters": 1200,
+                "request_timeout_seconds": 20,
+            },
+        },
         "git": {
             "auto_checkpoint": True,
             "auto_push": False,
@@ -59,6 +80,14 @@ def default_config(home: Path) -> dict:
             "sync_quest_on_open": True,
         },
         "bootstrap": {
+            "runner_readiness": {
+                name: {
+                    "ready": False,
+                    "last_checked_at": None,
+                    "last_result": {},
+                }
+                for name in list_builtin_runner_names()
+            },
             "codex_ready": False,
             "codex_last_checked_at": None,
             "codex_last_result": {},
@@ -91,35 +120,77 @@ def default_config(home: Path) -> dict:
 
 
 def default_runners() -> dict:
+    codex = get_runner_metadata("codex")
+    claude = get_runner_metadata("claude")
+    kimi = get_runner_metadata("kimi")
+    opencode = get_runner_metadata("opencode")
     return {
         "codex": {
             "enabled": True,
-            "binary": "codex",
-            "config_dir": "~/.codex",
+            "binary": codex.default_binary,
+            "config_dir": codex.default_config_dir,
             "profile": "",
             "model": "inherit",
             "model_reasoning_effort": "xhigh",
             "approval_policy": "never",
             "sandbox_mode": "danger-full-access",
             "retry_on_failure": True,
-            "retry_max_attempts": 5,
+            "retry_max_attempts": 7,
             "retry_initial_backoff_sec": 10.0,
             "retry_backoff_multiplier": 6.0,
             "retry_max_backoff_sec": 1800.0,
-            # Increase MCP tool timeout so codex can wait for long `bash_exec(mode='await', ...)`
-            # or other durable MCP calls without prematurely timing out.
-            # Mirrors DS_2027's `codex.mcp_tool_timeout_sec` default.
-            "mcp_tool_timeout_sec": 180000,
+            "mcp_tool_timeout_sec": 172800,
             "env": {},
         },
         "claude": {
             "enabled": False,
-            "binary": "claude",
-            "config_dir": "~/.claude",
+            "binary": claude.default_binary,
+            "config_dir": claude.default_config_dir,
+            "model": "inherit",
+            "permission_mode": "bypassPermissions",
+            "mcp_timeout_ms": 172800000,
+            "mcp_tool_timeout_ms": 172800000,
+            "retry_on_failure": True,
+            "retry_max_attempts": 4,
+            "retry_initial_backoff_sec": 10.0,
+            "retry_backoff_multiplier": 4.0,
+            "retry_max_backoff_sec": 600.0,
+            "env": {},
+            "status": "supported_experimental",
+        },
+        "kimi": {
+            "enabled": False,
+            "binary": kimi.default_binary,
+            "config_dir": kimi.default_config_dir,
             "model": "inherit",
-            "model_reasoning_effort": "",
+            "agent": "",
+            "thinking": False,
+            "yolo": True,
+            "mcp_tool_timeout_ms": 172800000,
+            "retry_on_failure": True,
+            "retry_max_attempts": 4,
+            "retry_initial_backoff_sec": 10.0,
+            "retry_backoff_multiplier": 4.0,
+            "retry_max_backoff_sec": 600.0,
+            "env": {},
+            "status": "supported_experimental",
+        },
+        "opencode": {
+            "enabled": False,
+            "binary": opencode.default_binary,
+            "config_dir": opencode.default_config_dir,
+            "model": "inherit",
+            "permission_mode": "allow",
+            "default_agent": "",
+            "variant": "",
+            "mcp_timeout_ms": 172800000,
+            "retry_on_failure": True,
+            "retry_max_attempts": 4,
+            "retry_initial_backoff_sec": 10.0,
+            "retry_backoff_multiplier": 4.0,
+            "retry_max_backoff_sec": 600.0,
             "env": {},
-            "status": "reserved_todo",
+            "status": "supported_experimental",
         },
     }