@researai/deepscientist 1.5.2 → 1.5.4

package/src/deepscientist/connector_profiles.py

@@ -0,0 +1,346 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any
+
+from .connector_runtime import infer_connector_transport
+from .shared import slugify
+
+
+PROFILEABLE_CONNECTOR_NAMES = ("telegram", "discord", "slack", "feishu", "whatsapp")
+
+
+CONNECTOR_PROFILE_SPECS: dict[str, dict[str, Any]] = {
+    "telegram": {
+        "profile_id_prefix": "telegram-profile",
+        "shared_fields": (
+            "enabled",
+            "profiles",
+            "transport",
+            "bot_name",
+            "bot_token",
+            "bot_token_env",
+            "command_prefix",
+            "dm_policy",
+            "allow_from",
+            "group_policy",
+            "group_allow_from",
+            "groups",
+            "require_mention_in_groups",
+            "auto_bind_dm_to_active_quest",
+        ),
+        "profile_defaults": {
+            "profile_id": None,
+            "enabled": True,
+            "transport": "polling",
+            "bot_name": "DeepScientist",
+            "bot_token": None,
+            "bot_token_env": "TELEGRAM_BOT_TOKEN",
+        },
+        "profile_fields": (
+            "enabled",
+            "transport",
+            "bot_name",
+            "bot_token",
+            "bot_token_env",
+        ),
+        "migration_keys": ("bot_token",),
+        "label_fields": ("bot_name",),
+        "id_fields": ("bot_name",),
+    },
+    "discord": {
+        "profile_id_prefix": "discord-profile",
+        "shared_fields": (
+            "enabled",
+            "profiles",
+            "transport",
+            "bot_name",
+            "bot_token",
+            "bot_token_env",
+            "command_prefix",
+            "application_id",
+            "dm_policy",
+            "allow_from",
+            "group_policy",
+            "group_allow_from",
+            "groups",
+            "require_mention_in_groups",
+            "auto_bind_dm_to_active_quest",
+            "guild_allowlist",
+        ),
+        "profile_defaults": {
+            "profile_id": None,
+            "enabled": True,
+            "transport": "gateway",
+            "bot_name": "DeepScientist",
+            "bot_token": None,
+            "bot_token_env": "DISCORD_BOT_TOKEN",
+            "application_id": None,
+        },
+        "profile_fields": (
+            "enabled",
+            "transport",
+            "bot_name",
+            "bot_token",
+            "bot_token_env",
+            "application_id",
+        ),
+        "migration_keys": ("bot_token", "application_id"),
+        "label_fields": ("bot_name", "application_id"),
+        "id_fields": ("application_id", "bot_name"),
+    },
+    "slack": {
+        "profile_id_prefix": "slack-profile",
+        "shared_fields": (
+            "enabled",
+            "profiles",
+            "transport",
+            "bot_name",
+            "bot_token",
+            "bot_token_env",
+            "bot_user_id",
+            "app_token",
+            "app_token_env",
+            "command_prefix",
+            "dm_policy",
+            "allow_from",
+            "group_policy",
+            "group_allow_from",
+            "groups",
+            "require_mention_in_groups",
+            "auto_bind_dm_to_active_quest",
+        ),
+        "profile_defaults": {
+            "profile_id": None,
+            "enabled": True,
+            "transport": "socket_mode",
+            "bot_name": "DeepScientist",
+            "bot_token": None,
+            "bot_token_env": "SLACK_BOT_TOKEN",
+            "bot_user_id": None,
+            "app_token": None,
+            "app_token_env": "SLACK_APP_TOKEN",
+        },
+        "profile_fields": (
+            "enabled",
+            "transport",
+            "bot_name",
+            "bot_token",
+            "bot_token_env",
+            "bot_user_id",
+            "app_token",
+            "app_token_env",
+        ),
+        "migration_keys": ("bot_token", "bot_user_id", "app_token"),
+        "label_fields": ("bot_name", "bot_user_id"),
+        "id_fields": ("bot_user_id", "bot_name"),
+    },
+    "feishu": {
+        "profile_id_prefix": "feishu-profile",
+        "shared_fields": (
+            "enabled",
+            "profiles",
+            "transport",
+            "bot_name",
+            "app_id",
+            "app_secret",
+            "app_secret_env",
+            "api_base_url",
+            "command_prefix",
+            "dm_policy",
+            "allow_from",
+            "group_policy",
+            "group_allow_from",
+            "groups",
+            "require_mention_in_groups",
+            "auto_bind_dm_to_active_quest",
+        ),
+        "profile_defaults": {
+            "profile_id": None,
+            "enabled": True,
+            "transport": "long_connection",
+            "bot_name": "DeepScientist",
+            "app_id": None,
+            "app_secret": None,
+            "app_secret_env": "FEISHU_APP_SECRET",
+            "api_base_url": "https://open.feishu.cn",
+        },
+        "profile_fields": (
+            "enabled",
+            "transport",
+            "bot_name",
+            "app_id",
+            "app_secret",
+            "app_secret_env",
+            "api_base_url",
+        ),
+        "migration_keys": ("app_id", "app_secret"),
+        "label_fields": ("bot_name", "app_id"),
+        "id_fields": ("app_id", "bot_name"),
+    },
+    "whatsapp": {
+        "profile_id_prefix": "whatsapp-profile",
+        "shared_fields": (
+            "enabled",
+            "profiles",
+            "transport",
+            "bot_name",
+            "auth_method",
+            "session_dir",
+            "command_prefix",
+            "dm_policy",
+            "allow_from",
+            "group_policy",
+            "group_allow_from",
+            "groups",
+            "auto_bind_dm_to_active_quest",
+        ),
+        "profile_defaults": {
+            "profile_id": None,
+            "enabled": True,
+            "transport": "local_session",
+            "bot_name": "DeepScientist",
+            "auth_method": "qr_browser",
+            "session_dir": "~/.deepscientist/connectors/whatsapp",
+        },
+        "profile_fields": (
+            "enabled",
+            "transport",
+            "bot_name",
+            "auth_method",
+            "session_dir",
+        ),
+        "migration_keys": ("session_dir",),
+        "label_fields": ("bot_name",),
+        "id_fields": ("bot_name",),
+    },
+}
+
+
+def _as_text(value: Any) -> str | None:
+    text = str(value or "").strip()
+    return text or None
+
+
+def _profile_seed(connector_name: str, raw: dict[str, Any], *, index: int) -> str:
+    spec = CONNECTOR_PROFILE_SPECS[connector_name]
+    explicit = _as_text(raw.get("profile_id"))
+    if explicit:
+        return explicit
+    for key in spec["id_fields"]:
+        candidate = _as_text(raw.get(key))
+        if candidate:
+            return f"{connector_name}-{candidate}"
+    return f"{spec['profile_id_prefix']}-{index:03d}"
+
+
+def _unique_profile_id(seed: str, *, prefix: str, used: set[str]) -> str:
+    base = slugify(seed, default=prefix)
+    candidate = base
+    suffix = 2
+    while candidate in used:
+        candidate = f"{base}-{suffix}"
+        suffix += 1
+    used.add(candidate)
+    return candidate
+
+
+def default_connector_profile(connector_name: str) -> dict[str, Any]:
+    spec = CONNECTOR_PROFILE_SPECS[connector_name]
+    return deepcopy(spec["profile_defaults"])
+
+
+def connector_profile_label(connector_name: str, profile: dict[str, Any] | None) -> str:
+    if not isinstance(profile, dict):
+        return connector_name.capitalize()
+    spec = CONNECTOR_PROFILE_SPECS[connector_name]
+    parts = [_as_text(profile.get(key)) for key in spec["label_fields"]]
+    filtered = [item for item in parts if item]
+    return " · ".join(filtered) if filtered else connector_name.capitalize()
+
+
+def normalize_connector_config(connector_name: str, config: dict[str, Any] | None) -> dict[str, Any]:
+    if connector_name not in CONNECTOR_PROFILE_SPECS:
+        raise KeyError(f"Connector `{connector_name}` does not support generic profile normalization.")
+    spec = CONNECTOR_PROFILE_SPECS[connector_name]
+    payload = deepcopy(config or {})
+    shared = {
+        key: deepcopy(payload.get(key))
+        for key in spec["shared_fields"]
+        if key in payload
+    }
+    shared["profiles"] = []
+
+    raw_profiles = payload.get("profiles")
+    items = list(raw_profiles) if isinstance(raw_profiles, list) else []
+    if not items and any(_as_text(payload.get(key)) for key in spec["migration_keys"]):
+        items = [{key: payload.get(key) for key in spec["profile_fields"]}]
+
+    used_ids: set[str] = set()
+    profiles: list[dict[str, Any]] = []
+    for index, raw in enumerate(items, start=1):
+        if not isinstance(raw, dict):
+            continue
+        current = default_connector_profile(connector_name)
+        for key in ("profile_id", *spec["profile_fields"]):
+            if key in raw:
+                current[key] = deepcopy(raw.get(key))
+        current["enabled"] = bool(current.get("enabled", True))
+        for key in spec["profile_fields"]:
+            if key in {"enabled", "transport", "mode"}:
+                continue
+            if isinstance(current.get(key), list):
+                continue
+            if current.get(key) is None:
+                continue
+            current[key] = _as_text(current.get(key))
+        current["transport"] = infer_connector_transport(connector_name, current)
+        if "mode" in spec["profile_defaults"] or current.get("mode") is not None:
+            current["mode"] = _as_text(current.get("mode")) or str(spec["profile_defaults"].get("mode") or "")
+        current["profile_id"] = _unique_profile_id(
+            _profile_seed(connector_name, current, index=index),
+            prefix=str(spec["profile_id_prefix"]),
+            used=used_ids,
+        )
+        profiles.append(current)
+
+    shared["transport"] = infer_connector_transport(connector_name, shared)
+    shared["profiles"] = profiles
+    if len(profiles) == 1:
+        for key in spec["profile_fields"]:
+            shared[key] = profiles[0].get(key)
+    return shared
+
+
+def list_connector_profiles(connector_name: str, config: dict[str, Any] | None) -> list[dict[str, Any]]:
+    normalized = normalize_connector_config(connector_name, config)
+    profiles = normalized.get("profiles")
+    return [dict(item) for item in profiles] if isinstance(profiles, list) else []
+
+
+def find_connector_profile(
+    connector_name: str,
+    config: dict[str, Any] | None,
+    *,
+    profile_id: str | None = None,
+) -> dict[str, Any] | None:
+    normalized_profile_id = _as_text(profile_id)
+    for profile in list_connector_profiles(connector_name, config):
+        if normalized_profile_id and str(profile.get("profile_id") or "").strip() == normalized_profile_id:
+            return profile
+    return None
+
+
+def merge_connector_profile_config(
+    connector_name: str,
+    shared_config: dict[str, Any] | None,
+    profile: dict[str, Any],
+) -> dict[str, Any]:
+    normalized = normalize_connector_config(connector_name, shared_config)
+    merged = deepcopy(normalized)
+    merged.pop("profiles", None)
+    for key in CONNECTOR_PROFILE_SPECS[connector_name]["profile_fields"]:
+        merged[key] = profile.get(key)
+    merged["profile_id"] = str(profile.get("profile_id") or "").strip() or None
+    merged["enabled"] = bool(normalized.get("enabled", False)) and bool(profile.get("enabled", True))
+    return merged

package/src/deepscientist/connector_runtime.py

@@ -3,69 +3,68 @@ from __future__ import annotations
 from typing import Any
 
 
+CONNECTOR_PROFILE_CHAT_ID_SEPARATOR = "::"
+QQ_PROFILE_CHAT_ID_SEPARATOR = CONNECTOR_PROFILE_CHAT_ID_SEPARATOR
+
+
 def infer_connector_transport(name: str, config: dict[str, Any] | None) -> str:
     normalized = str(name or "").strip().lower()
     payload = config or {}
     explicit = str(payload.get("transport") or "").strip().lower()
-    if explicit:
+    if explicit and explicit not in {
+        "relay",
+        "legacy_webhook",
+        "legacy_interactions",
+        "legacy_events_api",
+        "legacy_meta_cloud",
+    }:
         return explicit
 
-    relay_url = str(payload.get("relay_url") or "").strip()
-    mode = str(payload.get("mode") or "").strip().lower()
-    public_callback_url = str(payload.get("public_callback_url") or "").strip()
-
     if normalized == "qq":
         return "gateway_direct"
     if normalized == "telegram":
-        if relay_url and mode == "relay":
-            return "relay"
-        if public_callback_url or str(payload.get("webhook_secret") or "").strip():
-            return "legacy_webhook"
         return "polling"
     if normalized == "discord":
-        if relay_url and mode == "relay":
-            return "relay"
-        if str(payload.get("public_interactions_url") or "").strip() or str(payload.get("public_key") or "").strip():
-            return "legacy_interactions"
         return "gateway"
     if normalized == "slack":
-        if relay_url and mode == "relay":
-            return "relay"
         if str(payload.get("app_token") or "").strip():
             return "socket_mode"
-        if public_callback_url or str(payload.get("signing_secret") or "").strip():
-            return "legacy_events_api"
         return "socket_mode"
     if normalized == "feishu":
-        if relay_url and mode == "relay":
-            return "relay"
-        if (
-            public_callback_url
-            or str(payload.get("verification_token") or "").strip()
-            or str(payload.get("encrypt_key") or "").strip()
-        ):
-            return "legacy_webhook"
         return "long_connection"
     if normalized == "whatsapp":
-        provider = str(payload.get("provider") or "").strip().lower()
-        if relay_url and mode == "relay" and provider == "relay":
-            return "relay"
-        if (
-            provider == "meta"
-            or str(payload.get("access_token") or "").strip()
-            or str(payload.get("phone_number_id") or "").strip()
-            or str(payload.get("verify_token") or "").strip()
-            or public_callback_url
-        ):
-            return "legacy_meta_cloud"
         return "local_session"
     if normalized == "lingzhu":
         return "openclaw_sse"
-    if relay_url and mode == "relay":
-        return "relay"
     return "direct"
 
 
+def _decode_chat_id(*, connector: str, chat_id: str) -> tuple[str | None, str]:
+    if CONNECTOR_PROFILE_CHAT_ID_SEPARATOR not in chat_id:
+        return None, chat_id
+    profile_id, resolved_chat_id = chat_id.split(CONNECTOR_PROFILE_CHAT_ID_SEPARATOR, 1)
+    normalized_profile_id = str(profile_id or "").strip() or None
+    normalized_chat_id = str(resolved_chat_id or "").strip() or chat_id
+    return normalized_profile_id, normalized_chat_id
+
+
+def encode_chat_id(*, connector: str, chat_id: Any, profile_id: Any = None) -> str:
+    normalized_chat_id = str(chat_id or "").strip()
+    if not normalized_chat_id:
+        return ""
+    normalized_profile_id = str(profile_id or "").strip()
+    if not normalized_profile_id:
+        return normalized_chat_id
+    return f"{normalized_profile_id}{CONNECTOR_PROFILE_CHAT_ID_SEPARATOR}{normalized_chat_id}"
+
+
+def format_conversation_id(connector: str, chat_type: str, chat_id: Any, *, profile_id: Any = None) -> str:
+    normalized_connector = str(connector or "").strip().lower()
+    normalized_chat_type = str(chat_type or "").strip().lower()
+    encoded_chat_id = encode_chat_id(connector=normalized_connector, chat_id=chat_id, profile_id=profile_id)
+    return f"{normalized_connector}:{normalized_chat_type}:{encoded_chat_id}"
+
+
 def parse_conversation_id(conversation_id: Any) -> dict[str, str] | None:
     raw = str(conversation_id or "").strip()
     parts = raw.split(":", 2)
@@ -74,11 +73,14 @@ def parse_conversation_id(conversation_id: Any) -> dict[str, str] | None:
     connector, chat_type, chat_id = parts
     if not connector or not chat_type or not chat_id:
         return None
+    profile_id, resolved_chat_id = _decode_chat_id(connector=connector, chat_id=chat_id)
     return {
         "conversation_id": raw,
         "connector": connector,
         "chat_type": chat_type,
-        "chat_id": chat_id,
+        "chat_id": resolved_chat_id,
+        "chat_id_raw": chat_id,
+        "profile_id": profile_id or "",
     }
 
 
@@ -91,7 +93,12 @@ def normalize_conversation_id(conversation_id: Any) -> str:
         return "local:default"
     parsed = parse_conversation_id(raw)
     if parsed is not None:
-        return f"{parsed['connector'].lower()}:{parsed['chat_type'].lower()}:{parsed['chat_id']}"
+        return format_conversation_id(
+            parsed["connector"].lower(),
+            parsed["chat_type"].lower(),
+            parsed["chat_id"],
+            profile_id=parsed.get("profile_id") or None,
+        )
     if ":" in raw:
         return raw
     return f"{lowered}:default"
@@ -102,7 +109,17 @@ def conversation_identity_key(conversation_id: Any) -> str:
     parsed = parse_conversation_id(normalized)
     if parsed is None:
         return normalized.lower()
-    return f"{parsed['connector'].lower()}:{parsed['chat_type'].lower()}:{parsed['chat_id'].lower()}"
+    profile_key = str(parsed.get("profile_id") or "").strip().lower()
+    return ":".join(
+        item
+        for item in (
+            parsed["connector"].lower(),
+            profile_key,
+            parsed["chat_type"].lower(),
+            parsed["chat_id"].lower(),
+        )
+        if item
+    )
 
 
 def build_discovered_target(
@@ -113,6 +130,8 @@ def build_discovered_target(
     label: str | None = None,
     quest_id: str | None = None,
     updated_at: str | None = None,
+    profile_id: str | None = None,
+    profile_label: str | None = None,
 ) -> dict[str, Any] | None:
     parsed = parse_conversation_id(conversation_id)
     if parsed is None:
@@ -123,6 +142,10 @@ def build_discovered_target(
         "sources": [source],
         "label": label or f"{parsed['chat_type']} · {parsed['chat_id']}",
     }
+    if profile_id or parsed.get("profile_id"):
+        target["profile_id"] = str(profile_id or parsed.get("profile_id") or "").strip() or None
+    if profile_label:
+        target["profile_label"] = profile_label
     if is_default:
         target["is_default"] = True
     if quest_id:
@@ -140,9 +163,10 @@ def merge_discovered_targets(items: list[dict[str, Any] | None]) -> list[dict[st
         conversation_id = str(item.get("conversation_id") or "").strip()
         if not conversation_id:
             continue
-        existing = merged.get(conversation_id)
+        identity = conversation_identity_key(conversation_id)
+        existing = merged.get(identity)
         if existing is None:
-            merged[conversation_id] = dict(item)
+            merged[identity] = dict(item)
             continue
         sources = list(existing.get("sources") or [])
         for source in item.get("sources") or []:
@@ -161,6 +185,27 @@ def merge_discovered_targets(items: list[dict[str, Any] | None]) -> list[dict[st
             existing["label"] = item["label"]
         if not existing.get("source") and item.get("source"):
             existing["source"] = item["source"]
+        for key, value in item.items():
+            if key in {
+                "conversation_id",
+                "connector",
+                "chat_type",
+                "chat_id",
+                "sources",
+                "is_default",
+                "quest_id",
+                "updated_at",
+                "label",
+                "source",
+            }:
+                continue
+            if value is None:
+                continue
+            if key not in existing or existing.get(key) in {None, ""}:
+                existing[key] = value
+                continue
+            if key in {"bound_quest_id", "bound_quest_title", "warning", "first_seen_at"}:
+                existing[key] = value
 
     return sorted(
         merged.values(),