@researai/deepscientist 1.5.16 → 1.6.0

package/src/deepscientist/bridges/connectors.py

@@ -1021,8 +1021,13 @@ class WeixinConnectorBridge(BaseConnectorBridge):
     @classmethod
     def _retry_delays_for_item(cls, item: dict[str, Any], exc: Exception) -> tuple[float, ...]:
         message = str(exc or "").strip().lower()
-        if "ret=-2" in message and cls._item_type(item) in {4, 5}:
+        if "ret=-2" not in message:
+            return ()
+        item_type = cls._item_type(item)
+        if item_type in {4, 5}:
             return cls._MEDIA_SEND_RETRY_DELAYS_SECONDS
+        if item_type == 1:
+            return cls._TEXT_SEND_RETRY_DELAYS_SECONDS
         return ()
 
     def _send_items(
@@ -1044,7 +1049,8 @@ class WeixinConnectorBridge(BaseConnectorBridge):
             if media_item:
                 time.sleep(self._MEDIA_SEND_INITIAL_DELAY_SECONDS)
             retry_delays: tuple[float, ...] = ()
-            for attempt in range(1 + len(self._MEDIA_SEND_RETRY_DELAYS_SECONDS)):
+            max_retries = max(len(self._TEXT_SEND_RETRY_DELAYS_SECONDS), len(self._MEDIA_SEND_RETRY_DELAYS_SECONDS))
+            for attempt in range(1 + max_retries):
                 client_id = self._next_client_id()
                 try:
                     send_weixin_message(

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

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import ipaddress
 import json
 import re
 import shutil
@@ -7,14 +8,22 @@ import subprocess
 import tomllib
 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)
 _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")
+_ROOT_TABLE_SECTION_PATTERN = re.compile(r"^\s*\[")
+_ROOT_MODEL_ASSIGNMENT_PATTERN = re.compile(r"^\s*(model_provider|model)\s*=")
+_COMPAT_BEGIN_MARKER = "# BEGIN DEEPSCIENTIST PROFILE COMPAT"
+_COMPAT_END_MARKER = "# END DEEPSCIENTIST PROFILE COMPAT"
+_MISSING_ENV_PATTERN = re.compile(r"Missing environment variable:\s*[`'\"]?([^`'\"\s]+)", re.IGNORECASE)
+_LOCAL_PROVIDER_HOST_ALIASES = {"localhost", "host.docker.internal"}
 
 
 def parse_codex_cli_version(text: str) -> tuple[int, int, int] | None:
@@ -34,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
@@ -48,6 +57,50 @@ def format_codex_cli_version(version: tuple[int, int, int] | None) -> str:
     return ".".join(str(part) for part in version)
 
 
+def chat_wire_compatible_codex_version() -> tuple[int, int, int]:
+    return _CHAT_WIRE_COMPAT_VERSION
+
+
+def _split_root_table_lines(config_text: str) -> tuple[list[str], list[str]]:
+    lines = str(config_text or "").splitlines()
+    for index, line in enumerate(lines):
+        if _ROOT_TABLE_SECTION_PATTERN.match(line):
+            return lines[:index], lines[index:]
+    return lines, []
+
+
+def _strip_root_model_assignments(lines: list[str]) -> list[str]:
+    filtered: list[str] = []
+    skipping_compat_block = False
+    for line in lines:
+        stripped = line.strip()
+        if stripped == _COMPAT_BEGIN_MARKER:
+            skipping_compat_block = True
+            continue
+        if skipping_compat_block:
+            if stripped == _COMPAT_END_MARKER:
+                skipping_compat_block = False
+            continue
+        if _ROOT_MODEL_ASSIGNMENT_PATTERN.match(line):
+            continue
+        filtered.append(line)
+    while filtered and not filtered[0].strip():
+        filtered.pop(0)
+    while filtered and not filtered[-1].strip():
+        filtered.pop()
+    return filtered
+
+
+def _join_field_names(fields: list[str]) -> str:
+    if not fields:
+        return ""
+    if len(fields) == 1:
+        return fields[0]
+    if len(fields) == 2:
+        return f"{fields[0]} and {fields[1]}"
+    return ", ".join(fields[:-1]) + f", and {fields[-1]}"
+
+
 def normalize_codex_reasoning_effort(
     reasoning_effort: str | None,
     *,
@@ -93,33 +146,54 @@ def adapt_profile_only_provider_config(
     if not isinstance(profile_payload, dict):
         return config_text, None
 
-    prefix_lines: list[str] = []
-    injected_fields: list[str] = []
-    if "model_provider" not in parsed:
-        model_provider = str(profile_payload.get("model_provider") or "").strip()
-        if model_provider:
-            prefix_lines.append(f"model_provider = {json.dumps(model_provider, ensure_ascii=False)}")
-            injected_fields.append("model_provider")
-    if "model" not in parsed:
-        model = str(profile_payload.get("model") or "").strip()
-        if model:
-            prefix_lines.append(f"model = {json.dumps(model, ensure_ascii=False)}")
-            injected_fields.append("model")
-
-    if not prefix_lines:
+    profile_model_provider = str(profile_payload.get("model_provider") or "").strip()
+    profile_model = str(profile_payload.get("model") or "").strip()
+    top_level_model_provider = str(parsed.get("model_provider") or "").strip()
+    top_level_model = str(parsed.get("model") or "").strip()
+
+    root_lines: list[str] = []
+    changed_fields: list[str] = []
+    conflicted_fields: list[str] = []
+    if profile_model_provider and top_level_model_provider != profile_model_provider:
+        root_lines.append(f"model_provider = {json.dumps(profile_model_provider, ensure_ascii=False)}")
+        changed_fields.append("model_provider")
+        if top_level_model_provider:
+            conflicted_fields.append("model_provider")
+    elif profile_model_provider:
+        root_lines.append(f"model_provider = {json.dumps(profile_model_provider, ensure_ascii=False)}")
+    if profile_model and top_level_model != profile_model:
+        root_lines.append(f"model = {json.dumps(profile_model, ensure_ascii=False)}")
+        changed_fields.append("model")
+        if top_level_model:
+            conflicted_fields.append("model")
+    elif profile_model:
+        root_lines.append(f"model = {json.dumps(profile_model, ensure_ascii=False)}")
+
+    if not changed_fields:
         return config_text, None
 
-    adapted = (
-        "# BEGIN DEEPSCIENTIST PROFILE COMPAT\n"
-        + "\n".join(prefix_lines)
-        + "\n# END DEEPSCIENTIST PROFILE COMPAT\n\n"
-        + config_text.lstrip()
-    )
+    root_prefix, body_lines = _split_root_table_lines(config_text)
+    cleaned_root = _strip_root_model_assignments(root_prefix)
+    adapted_lines: list[str] = [
+        _COMPAT_BEGIN_MARKER,
+        *root_lines,
+        _COMPAT_END_MARKER,
+    ]
+    if cleaned_root:
+        adapted_lines.append("")
+        adapted_lines.extend(cleaned_root)
+    if body_lines:
+        adapted_lines.append("")
+        adapted_lines.extend(body_lines)
+    adapted = "\n".join(adapted_lines).rstrip() + "\n"
+    field_text = _join_field_names(changed_fields)
     return (
         adapted,
         (
-            f"DeepScientist promoted `{normalized_profile}` profile "
-            f"{', '.join(injected_fields)} to the top level for Codex compatibility."
+            f"DeepScientist overrode conflicting top-level {field_text} with values from profile "
+            f"`{normalized_profile}` for Codex compatibility."
+            if conflicted_fields
+            else f"DeepScientist promoted `{normalized_profile}` profile {field_text} to the top level for Codex compatibility."
         ),
     )
 
@@ -235,61 +309,47 @@ def materialize_codex_runtime_home(
     return warning
 
 
-def provider_profile_metadata(
+def _empty_provider_metadata() -> dict[str, str | bool | None]:
+    return {
+        "provider": None,
+        "model": None,
+        "env_key": None,
+        "base_url": None,
+        "wire_api": None,
+        "requires_openai_auth": None,
+    }
+
+
+def active_provider_metadata(
     config_text: str,
     *,
-    profile: str,
+    profile: str | None = None,
 ) -> 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,
-        }
+    if not str(config_text or "").strip():
+        return _empty_provider_metadata()
     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,
-        }
+        return _empty_provider_metadata()
+
+    profile_payload: dict | None = None
+    if normalized_profile:
+        profiles = parsed.get("profiles")
+        if not isinstance(profiles, dict):
+            return _empty_provider_metadata()
+        candidate_profile = profiles.get(normalized_profile)
+        if not isinstance(candidate_profile, dict):
+            return _empty_provider_metadata()
+        profile_payload = candidate_profile
 
     model_provider = str(
-        profile_payload.get("model_provider")
+        (profile_payload or {}).get("model_provider")
         or parsed.get("model_provider")
         or ""
     ).strip() or None
     model = str(
-        profile_payload.get("model")
+        (profile_payload or {}).get("model")
         or parsed.get("model")
         or ""
     ).strip() or None
@@ -331,6 +391,17 @@ def provider_profile_metadata(
     }
 
 
+def provider_profile_metadata(
+    config_text: str,
+    *,
+    profile: str,
+) -> dict[str, str | bool | None]:
+    normalized_profile = str(profile or "").strip()
+    if not normalized_profile:
+        return _empty_provider_metadata()
+    return active_provider_metadata(config_text, profile=normalized_profile)
+
+
 def provider_profile_metadata_from_home(
     config_home: str | Path,
     *,
@@ -338,12 +409,54 @@ def provider_profile_metadata_from_home(
 ) -> 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 _empty_provider_metadata()
     return provider_profile_metadata(config_path.read_text(encoding="utf-8"), profile=profile)
+
+
+def provider_base_url_looks_local(base_url: str | None) -> bool:
+    normalized = str(base_url or "").strip()
+    if not normalized:
+        return False
+    parsed = urlparse(normalized)
+    hostname = str(parsed.hostname or "").strip().lower()
+    if not hostname:
+        return False
+    if hostname in _LOCAL_PROVIDER_HOST_ALIASES or hostname.endswith(".local"):
+        return True
+    try:
+        ip = ipaddress.ip_address(hostname)
+    except ValueError:
+        return False
+    return ip.is_loopback or ip.is_private or ip.is_link_local or ip.is_unspecified
+
+
+def missing_provider_env_key(
+    metadata: dict[str, str | bool | None],
+    env: dict[str, str] | None,
+) -> str | None:
+    env_key = str((metadata or {}).get("env_key") or "").strip()
+    if not env_key:
+        return None
+    env_value = str((env or {}).get(env_key) or "").strip()
+    if env_value:
+        return None
+    return env_key
+
+
+def missing_provider_env_key_from_text(*texts: str) -> str | None:
+    for text in texts:
+        match = _MISSING_ENV_PATTERN.search(str(text or ""))
+        if match:
+            return str(match.group(1) or "").strip() or None
+    return None
+
+
+def active_provider_metadata_from_home(
+    config_home: str | Path,
+    *,
+    profile: str | None = None,
+) -> dict[str, str | bool | None]:
+    config_path = Path(config_home).expanduser() / "config.toml"
+    if not config_path.exists():
+        return _empty_provider_metadata()
+    return active_provider_metadata(config_path.read_text(encoding="utf-8"), profile=profile)