@researai/deepscientist 1.5.1 → 1.5.3

package/src/deepscientist/channels/slack_socket.py

@@ -9,6 +9,7 @@ from urllib.request import Request, urlopen
 from websockets.exceptions import ConnectionClosed
 from websockets.sync.client import connect as websocket_connect
 
+from ..connector_runtime import format_conversation_id
 from ..shared import read_json, utc_now, write_json
 
 
@@ -20,15 +21,23 @@ class SlackSocketModeService:
         config: dict[str, Any],
         on_event: Callable[[dict[str, Any]], None],
         log: Callable[[str, str], None] | None = None,
+        profile_id: str | None = None,
+        profile_label: str | None = None,
+        encode_profile_id: bool = False,
     ) -> None:
         self.home = home
         self.config = config
         self.on_event = on_event
         self.log = log or self._default_log
+        self.profile_id = str(profile_id or "").strip() or None
+        self.profile_label = str(profile_label or "").strip() or None
+        self._encode_profile_id = bool(encode_profile_id and self.profile_id)
         self._thread: threading.Thread | None = None
         self._stop_event = threading.Event()
         self._connection = None
         self._root = home / "logs" / "connectors" / "slack"
+        if self.profile_id:
+            self._root = self._root / "profiles" / self.profile_id
         self._runtime_path = self._root / "runtime.json"
 
     def start(self) -> bool:
@@ -64,7 +73,7 @@ class SlackSocketModeService:
         self._thread = threading.Thread(
             target=self._run,
             daemon=True,
-            name="deepscientist-slack-socket-mode",
+            name=f"deepscientist-slack-socket-mode-{self.profile_id or 'default'}",
         )
         self._thread.start()
         return True
@@ -208,14 +217,15 @@ class SlackSocketModeService:
             "sender_id": sender_id,
             "sender_name": str(event.get("username") or sender_id).strip(),
             "message_id": str(event.get("ts") or event.get("event_ts") or "").strip(),
-            "conversation_id": f"slack:{chat_type}:{channel_id}",
+            "conversation_id": self._conversation_id(chat_type, channel_id),
+            "profile_id": self.profile_id,
+            "profile_label": self.profile_label,
             "text": normalized_text,
             "mentioned": mentioned,
             "raw_event": payload,
         }
 
-    @staticmethod
-    def _normalize_slash_command(payload: dict[str, Any]) -> dict[str, Any] | None:
+    def _normalize_slash_command(self, payload: dict[str, Any]) -> dict[str, Any] | None:
         channel_id = str(payload.get("channel_id") or "").strip()
         if not channel_id:
             return None
@@ -232,12 +242,22 @@ class SlackSocketModeService:
             "sender_id": sender_id,
             "sender_name": str(payload.get("user_name") or sender_id).strip(),
             "message_id": str(payload.get("trigger_id") or "").strip(),
-            "conversation_id": f"slack:{chat_type}:{channel_id}",
+            "conversation_id": self._conversation_id(chat_type, channel_id),
+            "profile_id": self.profile_id,
+            "profile_label": self.profile_label,
             "text": combined,
             "mentioned": True,
             "raw_event": payload,
         }
 
+    def _conversation_id(self, chat_type: str, chat_id: str) -> str:
+        return format_conversation_id(
+            "slack",
+            chat_type,
+            chat_id,
+            profile_id=self.profile_id if self._encode_profile_id else None,
+        )
+
     @staticmethod
     def _infer_channel_type(channel_id: str) -> str:
         if str(channel_id).startswith("D"):
@@ -321,6 +341,10 @@ class SlackSocketModeService:
         state = read_json(self._runtime_path, {}) or {}
         if not isinstance(state, dict):
             state = {}
+        if self.profile_id:
+            state["profile_id"] = self.profile_id
+        if self.profile_label:
+            state["profile_label"] = self.profile_label
         state.update(patch)
         write_json(self._runtime_path, state)
 

package/src/deepscientist/channels/telegram_polling.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from typing import Any, Callable
 from urllib.request import Request, urlopen
 
+from ..connector_runtime import format_conversation_id
 from ..shared import read_json, utc_now, write_json
 
 
@@ -17,14 +18,22 @@ class TelegramPollingService:
         config: dict[str, Any],
         on_event: Callable[[dict[str, Any]], None],
         log: Callable[[str, str], None] | None = None,
+        profile_id: str | None = None,
+        profile_label: str | None = None,
+        encode_profile_id: bool = False,
     ) -> None:
         self.home = home
         self.config = config
         self.on_event = on_event
         self.log = log or self._default_log
+        self.profile_id = str(profile_id or "").strip() or None
+        self.profile_label = str(profile_label or "").strip() or None
+        self._encode_profile_id = bool(encode_profile_id and self.profile_id)
         self._thread: threading.Thread | None = None
         self._stop_event = threading.Event()
         self._root = home / "logs" / "connectors" / "telegram"
+        if self.profile_id:
+            self._root = self._root / "profiles" / self.profile_id
         self._runtime_path = self._root / "runtime.json"
 
     def start(self) -> bool:
@@ -59,7 +68,7 @@ class TelegramPollingService:
         self._thread = threading.Thread(
             target=self._run,
             daemon=True,
-            name="deepscientist-telegram-polling",
+            name=f"deepscientist-telegram-polling-{self.profile_id or 'default'}",
         )
         self._thread.start()
         return True
@@ -219,12 +228,22 @@ class TelegramPollingService:
             "sender_id": sender_id,
             "sender_name": sender_name,
             "message_id": str(message.get("message_id") or "").strip(),
-            "conversation_id": f"telegram:{chat_type}:{chat_id}",
+            "conversation_id": self._conversation_id(chat_type, chat_id),
+            "profile_id": self.profile_id,
+            "profile_label": self.profile_label,
             "text": normalized_text,
             "mentioned": mentioned,
             "raw_event": update,
         }
 
+    def _conversation_id(self, chat_type: str, chat_id: str) -> str:
+        return format_conversation_id(
+            "telegram",
+            chat_type,
+            chat_id,
+            profile_id=self.profile_id if self._encode_profile_id else None,
+        )
+
     @staticmethod
     def _normalize_command_target(text: str, *, bot_name: str) -> str:
         cleaned = str(text or "").strip()
@@ -272,6 +291,10 @@ class TelegramPollingService:
         state = read_json(self._runtime_path, {}) or {}
         if not isinstance(state, dict):
             state = {}
+        if self.profile_id:
+            state["profile_id"] = self.profile_id
+        if self.profile_label:
+            state["profile_label"] = self.profile_label
         state.update(patch)
         write_json(self._runtime_path, state)
 

package/src/deepscientist/channels/whatsapp_local_session.py

@@ -5,6 +5,7 @@ import threading
 from pathlib import Path
 from typing import Any, Callable
 
+from ..connector_runtime import format_conversation_id, parse_conversation_id
 from ..shared import append_jsonl, ensure_dir, read_json, utc_now, write_json
 
 
@@ -16,14 +17,22 @@ class WhatsAppLocalSessionService:
         config: dict[str, Any],
         on_event: Callable[[dict[str, Any]], None],
         log: Callable[[str, str], None] | None = None,
+        profile_id: str | None = None,
+        profile_label: str | None = None,
+        encode_profile_id: bool = False,
     ) -> None:
         self.home = home
         self.config = config
         self.on_event = on_event
         self.log = log or self._default_log
+        self.profile_id = str(profile_id or "").strip() or None
+        self.profile_label = str(profile_label or "").strip() or None
+        self._encode_profile_id = bool(encode_profile_id and self.profile_id)
         self._thread: threading.Thread | None = None
         self._stop_event = threading.Event()
         self._root = home / "logs" / "connectors" / "whatsapp"
+        if self.profile_id:
+            self._root = self._root / "profiles" / self.profile_id
         self._runtime_path = self._root / "runtime.json"
         self._cursor_path = self._root / "local_session.cursor.json"
 
@@ -60,7 +69,7 @@ class WhatsAppLocalSessionService:
         self._thread = threading.Thread(
             target=self._run,
             daemon=True,
-            name="deepscientist-whatsapp-local-session",
+            name=f"deepscientist-whatsapp-local-session-{self.profile_id or 'default'}",
         )
         self._thread.start()
         return True
@@ -165,11 +174,16 @@ class WhatsAppLocalSessionService:
                 )
         write_json(self._cursor_path, {"offset": offset})
 
-    @staticmethod
-    def _normalize_entry(payload: dict[str, Any]) -> dict[str, Any] | None:
+    def _normalize_entry(self, payload: dict[str, Any]) -> dict[str, Any] | None:
         if isinstance(payload.get("normalized"), dict):
             normalized = dict(payload["normalized"])
             normalized.setdefault("raw_event", payload)
+            parsed = parse_conversation_id(normalized.get("conversation_id"))
+            chat_type = str((parsed or {}).get("chat_type") or normalized.get("chat_type") or "direct").strip().lower() or "direct"
+            chat_id = str((parsed or {}).get("chat_id") or normalized.get("group_id") or normalized.get("direct_id") or "").strip() or "unknown"
+            normalized["conversation_id"] = self._conversation_id(chat_type, chat_id)
+            normalized["profile_id"] = self.profile_id
+            normalized["profile_label"] = self.profile_label
             return normalized
         conversation_id = str(payload.get("conversation_id") or "").strip()
         chat_type = str(payload.get("chat_type") or "").strip().lower()
@@ -201,12 +215,22 @@ class WhatsAppLocalSessionService:
             "sender_id": sender_id or chat_id,
             "sender_name": sender_name or sender_id or chat_id,
             "message_id": message_id,
-            "conversation_id": conversation_id or f"whatsapp:{chat_type}:{chat_id}",
+            "conversation_id": self._conversation_id(chat_type, chat_id),
+            "profile_id": self.profile_id,
+            "profile_label": self.profile_label,
             "text": text,
             "mentioned": False,
             "raw_event": payload,
         }
 
+    def _conversation_id(self, chat_type: str, chat_id: str) -> str:
+        return format_conversation_id(
+            "whatsapp",
+            chat_type,
+            chat_id,
+            profile_id=self.profile_id if self._encode_profile_id else None,
+        )
+
     def _session_dir(self) -> Path | None:
         raw = str(self.config.get("session_dir") or "").strip()
         if not raw:
@@ -217,6 +241,10 @@ class WhatsAppLocalSessionService:
         state = read_json(self._runtime_path, {}) or {}
         if not isinstance(state, dict):
             state = {}
+        if self.profile_id:
+            state["profile_id"] = self.profile_id
+        if self.profile_label:
+            state["profile_label"] = self.profile_label
         state.update(patch)
         write_json(self._runtime_path, state)
 

package/src/deepscientist/cli.py

@@ -17,6 +17,7 @@ from .daemon import DaemonApp
 from .doctor import render_doctor_report, run_doctor
 from .home import default_home, ensure_home_layout, repo_root
 from .memory import MemoryService
+from .migration import migrate_deepscientist_root
 from .prompts import PromptBuilder
 from .quest import QuestService
 from .registries import BaselineRegistry
@@ -109,6 +110,9 @@ def build_parser() -> argparse.ArgumentParser:
     config_edit.add_argument("name", choices=("config", "runners", "connectors", "plugins", "mcp_servers"))
     config_subparsers.add_parser("validate")
 
+    migrate_parser = subparsers.add_parser("migrate")
+    migrate_parser.add_argument("target")
+
     return parser
 
 
@@ -445,6 +449,27 @@ def config_validate_command(home: Path) -> int:
     return 0
 
 
+def migrate_command(home: Path, target: str) -> int:
+    try:
+        payload = migrate_deepscientist_root(home, Path(target))
+    except ValueError as exc:
+        print(
+            json.dumps(
+                {
+                    "ok": False,
+                    "source": str(home.expanduser().resolve()),
+                    "target": str(Path(target).expanduser().resolve()),
+                    "message": str(exc),
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+        )
+        return 1
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    return 0
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = build_parser()
     args = parser.parse_args(argv)
@@ -492,6 +517,8 @@ def main(argv: list[str] | None = None) -> int:
         return config_edit_command(home, args.name)
     if args.command == "config" and args.config_command == "validate":
         return config_validate_command(home)
+    if args.command == "migrate":
+        return migrate_command(home, args.target)
     parser.error(f"Unknown command: {args.command}")
     return 1
 

package/src/deepscientist/config/models.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 from pathlib import Path
 
-
 CONFIG_NAMES = ("config", "runners", "connectors", "plugins", "mcp_servers")
 REQUIRED_CONFIG_NAMES = ("config", "runners", "connectors")
 OPTIONAL_CONFIG_NAMES = ("plugins", "mcp_servers")
@@ -122,6 +121,7 @@ def default_connectors() -> dict:
         "qq": {
             "enabled": False,
             "transport": "gateway_direct",
+            "profiles": [],
             "app_id": None,
             "app_secret": None,
             "app_secret_env": "QQ_APP_SECRET",
@@ -140,17 +140,12 @@ def default_connectors() -> dict:
         },
         "telegram": {
             "enabled": False,
+            "profiles": [],
             "transport": "polling",
-            "mode": "relay",
             "bot_name": "DeepScientist",
             "command_prefix": "/",
             "bot_token": None,
             "bot_token_env": "TELEGRAM_BOT_TOKEN",
-            "webhook_secret": None,
-            "webhook_secret_env": "TELEGRAM_WEBHOOK_SECRET",
-            "public_callback_url": None,
-            "relay_url": None,
-            "relay_auth_token": None,
             "dm_policy": "pairing",
             "allow_from": [],
             "group_policy": "open",
@@ -161,18 +156,13 @@ def default_connectors() -> dict:
         },
         "discord": {
             "enabled": False,
+            "profiles": [],
             "transport": "gateway",
-            "mode": "relay",
             "bot_name": "DeepScientist",
             "command_prefix": "/",
             "bot_token": None,
             "bot_token_env": "DISCORD_BOT_TOKEN",
             "application_id": None,
-            "public_key": None,
-            "public_key_env": "DISCORD_PUBLIC_KEY",
-            "public_interactions_url": None,
-            "relay_url": None,
-            "relay_auth_token": None,
             "dm_policy": "pairing",
             "allow_from": [],
             "group_policy": "open",
@@ -184,8 +174,8 @@ def default_connectors() -> dict:
         },
         "slack": {
             "enabled": False,
+            "profiles": [],
             "transport": "socket_mode",
-            "mode": "relay",
             "bot_name": "DeepScientist",
             "command_prefix": "/",
             "bot_token": None,
@@ -193,11 +183,6 @@ def default_connectors() -> dict:
             "bot_user_id": None,
             "app_token": None,
             "app_token_env": "SLACK_APP_TOKEN",
-            "signing_secret": None,
-            "signing_secret_env": "SLACK_SIGNING_SECRET",
-            "public_callback_url": None,
-            "relay_url": None,
-            "relay_auth_token": None,
             "dm_policy": "pairing",
             "allow_from": [],
             "group_policy": "open",
@@ -208,21 +193,14 @@ def default_connectors() -> dict:
         },
         "feishu": {
             "enabled": False,
+            "profiles": [],
             "transport": "long_connection",
-            "mode": "relay",
             "bot_name": "DeepScientist",
             "command_prefix": "/",
             "app_id": None,
             "app_secret": None,
             "app_secret_env": "FEISHU_APP_SECRET",
-            "verification_token": None,
-            "verification_token_env": "FEISHU_VERIFICATION_TOKEN",
-            "encrypt_key": None,
-            "encrypt_key_env": "FEISHU_ENCRYPT_KEY",
             "api_base_url": "https://open.feishu.cn",
-            "public_callback_url": None,
-            "relay_url": None,
-            "relay_auth_token": None,
             "dm_policy": "pairing",
             "allow_from": [],
             "group_policy": "open",
@@ -233,24 +211,12 @@ def default_connectors() -> dict:
         },
         "whatsapp": {
             "enabled": False,
+            "profiles": [],
             "transport": "local_session",
-            "mode": "relay",
             "bot_name": "DeepScientist",
             "command_prefix": "/",
             "auth_method": "qr_browser",
             "session_dir": "~/.deepscientist/connectors/whatsapp",
-            "provider": "relay",
-            "access_token": None,
-            "access_token_env": "WHATSAPP_ACCESS_TOKEN",
-            "phone_number_id": None,
-            "business_account_id": None,
-            "verify_token": None,
-            "verify_token_env": "WHATSAPP_VERIFY_TOKEN",
-            "api_base_url": "https://graph.facebook.com",
-            "api_version": "v21.0",
-            "public_callback_url": None,
-            "relay_url": None,
-            "relay_auth_token": None,
             "dm_policy": "pairing",
             "allow_from": [],
             "group_policy": "allowlist",