feat(channels): add multi-channel management UI with real-time connect/disconnect

- Web console Channels page: display active channels as config cards, support
  save/connect/disconnect with real-time start/stop of channel processes
- Custom dropdown for channel selection (consistent with model selector style),
  custom confirmation dialog for disconnect
- Fix channel stop: use sys.modules['__main__'] to access live ChannelManager
- Fix web request pending: move stop logic outside lock, set daemon_threads=True
- Fix reconnect: new asyncio event loop per startup, ctypes thread interrupt,
  5s grace period before re-establishing remote connection
- Filter stale offline messages (>60s) pushed after reconnect

README.md

@@ -24,8 +24,9 @@
 
 ## 声明
 
-1. 本项目遵循 [MIT开源协议](/LICENSE)，主要用于技术研究和学习，使用本项目时需遵守所在地法律法规、相关政策以及企业章程，禁止用于任何违法或侵犯他人权益的行为。任何个人、团队和企业，无论以何种方式使用该项目、对何对象提供服务，所产生的一切后果，本项目均不承担任何责任
-2. 成本与安全：Agent模式下Token使用量高于普通对话模式，请根据效果及成本综合选择模型。Agent具有访问所在操作系统的能力，请谨慎选择项目部署环境。同时项目也会持续升级安全机制、并降低模型消耗成本
+1. 本项目遵循 [MIT开源协议](/LICENSE)，主要用于技术研究和学习，使用本项目时需遵守所在地法律法规、相关政策以及企业章程，禁止用于任何违法或侵犯他人权益的行为。任何个人、团队和企业，无论以何种方式使用该项目、对何对象提供服务，所产生的一切后果，本项目均不承担任何责任。
+2. 成本与安全：Agent模式下Token使用量高于普通对话模式，请根据效果及成本综合选择模型。Agent具有访问所在操作系统的能力，请谨慎选择项目部署环境。同时项目也会持续升级安全机制、并降低模型消耗成本。
+3. CowAgent项目专注于开源技术开发，不会参与、授权或发行任何加密货币。
 
 ## 演示
 
@@ -607,10 +608,12 @@ API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn)
 
 以下对可接入通道的配置方式进行说明，应用通道代码在项目的 `channel/` 目录下。
 
+支持同时可接入多个通道，配置时可通过逗号进行分割，例如 `"channel_type": "feishu,dingtalk"`。
+
 <details>
 <summary>1. Web</summary>
 
-项目启动后默认运行Web通道，配置如下：
+项目启动后会默认运行Web控制台，配置如下：
 
 ```json
 {

agent/chat/service.py

@@ -158,6 +158,7 @@ class ChatService:
         logger.info(f"[ChatService] Agent run completed: session={session_id}")
 
 
+
 class _StreamState:
     """Mutable state shared between the event callback and the run method."""
 

agent/memory/__init__.py

@@ -1,11 +1,21 @@
 """
 Memory module for AgentMesh
 
-Provides long-term memory capabilities with hybrid search (vector + keyword)
+Provides both long-term memory (vector/keyword search) and short-term
+conversation history persistence (SQLite).
 """
 
 from agent.memory.manager import MemoryManager
 from agent.memory.config import MemoryConfig, get_default_memory_config, set_global_memory_config
 from agent.memory.embedding import create_embedding_provider
+from agent.memory.conversation_store import ConversationStore, get_conversation_store
 
-__all__ = ['MemoryManager', 'MemoryConfig', 'get_default_memory_config', 'set_global_memory_config', 'create_embedding_provider']
+__all__ = [
+    'MemoryManager',
+    'MemoryConfig',
+    'get_default_memory_config',
+    'set_global_memory_config',
+    'create_embedding_provider',
+    'ConversationStore',
+    'get_conversation_store',
+]

agent/memory/conversation_store.py

@@ -0,0 +1,618 @@
+"""
+Conversation history persistence using SQLite.
+
+Design:
+- sessions table: per-session metadata (channel_type, last_active, msg_count)
+- messages table: individual messages stored as JSON, append-only
+- Pruning: age-based only (sessions not updated within N days are deleted)
+- Thread-safe via a single in-process lock
+
+Storage path: ~/cow/sessions/conversations.db
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+import threading
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from common.log import logger
+
+
+# ---------------------------------------------------------------------------
+# Schema
+# ---------------------------------------------------------------------------
+
+_DDL = """
+CREATE TABLE IF NOT EXISTS sessions (
+    session_id   TEXT    PRIMARY KEY,
+    channel_type TEXT    NOT NULL DEFAULT '',
+    created_at   INTEGER NOT NULL,
+    last_active  INTEGER NOT NULL,
+    msg_count    INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+    id           INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id   TEXT    NOT NULL,
+    seq          INTEGER NOT NULL,
+    role         TEXT    NOT NULL,
+    content      TEXT    NOT NULL,
+    created_at   INTEGER NOT NULL,
+    UNIQUE (session_id, seq)
+);
+
+CREATE INDEX IF NOT EXISTS idx_messages_session
+    ON messages (session_id, seq);
+
+CREATE INDEX IF NOT EXISTS idx_sessions_last_active
+    ON sessions (last_active);
+"""
+
+# Migration: add channel_type column to existing databases that predate it.
+_MIGRATION_ADD_CHANNEL_TYPE = """
+ALTER TABLE sessions ADD COLUMN channel_type TEXT NOT NULL DEFAULT '';
+"""
+
+DEFAULT_MAX_AGE_DAYS: int = 30
+
+
+def _is_visible_user_message(content: Any) -> bool:
+    """
+    Return True when a user-role message represents actual user input
+    (not an internal tool_result injected by the agent loop).
+    """
+    if isinstance(content, str):
+        return bool(content.strip())
+    if isinstance(content, list):
+        return any(
+            isinstance(b, dict) and b.get("type") == "text"
+            for b in content
+        )
+    return False
+
+
+def _extract_display_text(content: Any) -> str:
+    """
+    Extract the human-readable text portion from a message content value.
+    Returns an empty string for tool_use / tool_result blocks.
+    """
+    if isinstance(content, str):
+        return content.strip()
+    if isinstance(content, list):
+        parts = [
+            b.get("text", "")
+            for b in content
+            if isinstance(b, dict) and b.get("type") == "text"
+        ]
+        return "\n".join(p for p in parts if p).strip()
+    return ""
+
+
+def _extract_tool_calls(content: Any) -> List[Dict[str, Any]]:
+    """
+    Extract tool_use blocks from an assistant message content.
+    Returns a list of {name, arguments} dicts (result filled in later).
+    """
+    if not isinstance(content, list):
+        return []
+    return [
+        {"id": b.get("id", ""), "name": b.get("name", ""), "arguments": b.get("input", {})}
+        for b in content
+        if isinstance(b, dict) and b.get("type") == "tool_use"
+    ]
+
+
+def _extract_tool_results(content: Any) -> Dict[str, str]:
+    """
+    Extract tool_result blocks from a user message, keyed by tool_use_id.
+    """
+    if not isinstance(content, list):
+        return {}
+    results = {}
+    for b in content:
+        if not isinstance(b, dict) or b.get("type") != "tool_result":
+            continue
+        tool_id = b.get("tool_use_id", "")
+        result_content = b.get("content", "")
+        if isinstance(result_content, list):
+            result_content = "\n".join(
+                rb.get("text", "") for rb in result_content
+                if isinstance(rb, dict) and rb.get("type") == "text"
+            )
+        results[tool_id] = str(result_content)
+    return results
+
+
+def _group_into_display_turns(
+    rows: List[tuple],
+) -> List[Dict[str, Any]]:
+    """
+    Convert raw (role, content_json, created_at) DB rows into display turns.
+
+    One display turn = one visible user message  +  one merged assistant reply.
+    All intermediate assistant messages (those carrying tool_use) and the final
+    assistant text reply produced for the same user query are collapsed into a
+    single assistant turn, exactly matching the live SSE rendering where tools
+    and the final answer appear inside the same bubble.
+
+    Grouping rules:
+    - A visible user message starts a new group.
+    - tool_result user messages are internal; their content is attached to the
+      matching tool_use entry via tool_use_id and they never become own turns.
+    - All assistant messages within a group are merged:
+        * tool_use blocks → tool_calls list (result filled from tool_results)
+        * text blocks → last non-empty text becomes the display content
+    """
+    # ------------------------------------------------------------------ #
+    # Pass 1: split rows into groups, each starting with a visible user msg
+    # ------------------------------------------------------------------ #
+    # group = (user_row | None, [subsequent_rows])
+    # user_row: (content, created_at)
+    groups: List[tuple] = []
+    cur_user: Optional[tuple] = None
+    cur_rest: List[tuple] = []
+    started = False
+
+    for role, raw_content, created_at in rows:
+        try:
+            content = json.loads(raw_content)
+        except Exception:
+            content = raw_content
+
+        if role == "user" and _is_visible_user_message(content):
+            if started:
+                groups.append((cur_user, cur_rest))
+            cur_user = (content, created_at)
+            cur_rest = []
+            started = True
+        else:
+            cur_rest.append((role, content, created_at))
+
+    if started:
+        groups.append((cur_user, cur_rest))
+
+    # ------------------------------------------------------------------ #
+    # Pass 2: build display turns from each group
+    # ------------------------------------------------------------------ #
+    turns: List[Dict[str, Any]] = []
+
+    for user_row, rest in groups:
+        # User turn
+        if user_row:
+            content, created_at = user_row
+            text = _extract_display_text(content)
+            if text:
+                turns.append({"role": "user", "content": text, "created_at": created_at})
+
+        # Collect all tool_calls and tool_results from the rest of the group
+        all_tool_calls: List[Dict[str, Any]] = []
+        tool_results: Dict[str, str] = {}
+        final_text = ""
+        final_ts: Optional[int] = None
+
+        for role, content, created_at in rest:
+            if role == "user":
+                tool_results.update(_extract_tool_results(content))
+            elif role == "assistant":
+                tcs = _extract_tool_calls(content)
+                all_tool_calls.extend(tcs)
+                t = _extract_display_text(content)
+                if t:
+                    final_text = t
+                final_ts = created_at
+
+        # Attach tool results to their matching tool_call entries
+        for tc in all_tool_calls:
+            tc["result"] = tool_results.get(tc.get("id", ""), "")
+
+        if final_text or all_tool_calls:
+            turns.append({
+                "role": "assistant",
+                "content": final_text,
+                "tool_calls": all_tool_calls,
+                "created_at": final_ts or (user_row[1] if user_row else 0),
+            })
+
+    return turns
+
+
+class ConversationStore:
+    """
+    SQLite-backed store for per-session conversation history.
+
+    Usage:
+        store = ConversationStore(db_path)
+        store.append_messages("user_123", new_messages, channel_type="feishu")
+        msgs = store.load_messages("user_123", max_turns=30)
+    """
+
+    def __init__(self, db_path: Path):
+        self._db_path = db_path
+        self._lock = threading.Lock()
+        self._init_db()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def load_messages(
+        self,
+        session_id: str,
+        max_turns: int = 30,
+    ) -> List[Dict[str, Any]]:
+        """
+        Load the most recent messages for a session, for injection into the LLM.
+
+        ALL message types (user text, assistant tool_use, tool_result) are returned
+        in their original JSON form so the LLM can reconstruct the full context.
+
+        max_turns is a *visible-turn* count: we count only user messages whose
+        content is actual user text (not tool_result blocks).  This prevents
+        tool-heavy sessions from exhausting the turn budget prematurely.
+
+        Args:
+            session_id: Unique session identifier.
+            max_turns: Maximum number of visible user-assistant turns to keep.
+
+        Returns:
+            Chronologically ordered list of message dicts (role, content).
+        """
+        with self._lock:
+            conn = self._connect()
+            try:
+                rows = conn.execute(
+                    """
+                    SELECT seq, role, content
+                    FROM messages
+                    WHERE session_id = ?
+                    ORDER BY seq DESC
+                    """,
+                    (session_id,),
+                ).fetchall()
+            finally:
+                conn.close()
+
+        if not rows:
+            return []
+
+        # Walk newest-to-oldest counting *visible* user turns (actual user text,
+        # not tool_result injections).  Record the seq of every visible user
+        # message so we can find a clean cut point later.
+        visible_turn_seqs: List[int] = []  # newest first
+        for seq, role, raw_content in rows:
+            if role != "user":
+                continue
+            try:
+                content = json.loads(raw_content)
+            except Exception:
+                content = raw_content
+            if _is_visible_user_message(content):
+                visible_turn_seqs.append(seq)
+
+        # Determine the seq of the oldest visible user message we want to keep.
+        # If the total turns fit within max_turns, keep everything.
+        if len(visible_turn_seqs) <= max_turns:
+            cutoff_seq = None  # keep all
+        else:
+            # The Nth visible user message (0-indexed) is the oldest we keep.
+            cutoff_seq = visible_turn_seqs[max_turns - 1]
+
+        # Build result in chronological order, starting from cutoff.
+        # IMPORTANT: we start exactly at cutoff_seq (the visible user message),
+        # never mid-group, so tool_use / tool_result pairs are always complete.
+        result = []
+        for seq, role, raw_content in reversed(rows):
+            if cutoff_seq is not None and seq < cutoff_seq:
+                continue
+            try:
+                content = json.loads(raw_content)
+            except Exception:
+                content = raw_content
+            result.append({"role": role, "content": content})
+        return result
+
+    def append_messages(
+        self,
+        session_id: str,
+        messages: List[Dict[str, Any]],
+        channel_type: str = "",
+    ) -> None:
+        """
+        Append new messages to a session's history.
+
+        Seq numbers continue from the session's current maximum, so
+        concurrent callers on distinct sessions never collide.
+
+        Args:
+            session_id: Unique session identifier.
+            messages: List of message dicts to append.
+            channel_type: Source channel (e.g. "feishu", "web", "wechat").
+                          Only written on session creation; ignored on update.
+        """
+        if not messages:
+            return
+
+        now = int(time.time())
+        with self._lock:
+            conn = self._connect()
+            try:
+                with conn:
+                    # INSERT OR IGNORE creates the row on first visit;
+                    # the UPDATE always refreshes last_active.
+                    # Avoids ON CONFLICT...DO UPDATE (requires SQLite >= 3.24).
+                    conn.execute(
+                        """
+                        INSERT OR IGNORE INTO sessions
+                            (session_id, channel_type, created_at, last_active, msg_count)
+                        VALUES (?, ?, ?, ?, 0)
+                        """,
+                        (session_id, channel_type, now, now),
+                    )
+                    conn.execute(
+                        "UPDATE sessions SET last_active = ? WHERE session_id = ?",
+                        (now, session_id),
+                    )
+
+                    # Determine starting seq for the new batch.
+                    row = conn.execute(
+                        "SELECT COALESCE(MAX(seq), -1) FROM messages WHERE session_id = ?",
+                        (session_id,),
+                    ).fetchone()
+                    next_seq = row[0] + 1
+
+                    for msg in messages:
+                        role = msg.get("role", "")
+                        content = json.dumps(
+                            msg.get("content", ""), ensure_ascii=False
+                        )
+                        conn.execute(
+                            """
+                            INSERT OR IGNORE INTO messages
+                                (session_id, seq, role, content, created_at)
+                            VALUES (?, ?, ?, ?, ?)
+                            """,
+                            (session_id, next_seq, role, content, now),
+                        )
+                        next_seq += 1
+
+                    conn.execute(
+                        """
+                        UPDATE sessions
+                        SET msg_count = (
+                            SELECT COUNT(*) FROM messages WHERE session_id = ?
+                        )
+                        WHERE session_id = ?
+                        """,
+                        (session_id, session_id),
+                    )
+            finally:
+                conn.close()
+
+    def clear_session(self, session_id: str) -> None:
+        """Delete all messages and the session record for a given session_id."""
+        with self._lock:
+            conn = self._connect()
+            try:
+                with conn:
+                    conn.execute(
+                        "DELETE FROM messages WHERE session_id = ?", (session_id,)
+                    )
+                    conn.execute(
+                        "DELETE FROM sessions WHERE session_id = ?", (session_id,)
+                    )
+            finally:
+                conn.close()
+
+    def cleanup_old_sessions(self, max_age_days: Optional[int] = None) -> int:
+        """
+        Delete sessions that have not been active within max_age_days.
+
+        Args:
+            max_age_days: Override the default retention period.
+
+        Returns:
+            Number of sessions deleted.
+        """
+        try:
+            from config import conf
+            max_age = max_age_days or conf().get(
+                "conversation_max_age_days", DEFAULT_MAX_AGE_DAYS
+            )
+        except Exception:
+            max_age = max_age_days or DEFAULT_MAX_AGE_DAYS
+
+        cutoff = int(time.time()) - max_age * 86400
+        deleted = 0
+
+        with self._lock:
+            conn = self._connect()
+            try:
+                with conn:
+                    stale = conn.execute(
+                        "SELECT session_id FROM sessions WHERE last_active < ?",
+                        (cutoff,),
+                    ).fetchall()
+                    for (sid,) in stale:
+                        conn.execute(
+                            "DELETE FROM messages WHERE session_id = ?", (sid,)
+                        )
+                        conn.execute(
+                            "DELETE FROM sessions WHERE session_id = ?", (sid,)
+                        )
+                        deleted += 1
+            finally:
+                conn.close()
+
+        if deleted:
+            logger.info(f"[ConversationStore] Pruned {deleted} expired sessions")
+        return deleted
+
+    def load_history_page(
+        self,
+        session_id: str,
+        page: int = 1,
+        page_size: int = 20,
+    ) -> Dict[str, Any]:
+        """
+        Load a page of conversation history for UI display, grouped into turns.
+
+        Each "turn" maps to one of:
+          - A user message (role="user", content=str)
+          - An assistant message (role="assistant", content=str,
+            tool_calls=[{name, arguments, result}] when tools were used)
+
+        Internal tool_result user messages are merged into the preceding
+        assistant entry's tool_calls list and never appear as standalone items.
+
+        Pages are numbered from 1 (most recent).  Messages within a page are
+        returned in chronological order.
+
+        Returns:
+            {
+                "messages": [
+                    {
+                        "role": "user" | "assistant",
+                        "content": str,
+                        "tool_calls": [...],   # assistant only, may be []
+                        "created_at": int,
+                    },
+                    ...
+                ],
+                "total": <visible turn count>,
+                "page": <current page>,
+                "page_size": <page_size>,
+                "has_more": bool,
+            }
+        """
+        page = max(1, page)
+        with self._lock:
+            conn = self._connect()
+            try:
+                rows = conn.execute(
+                    """
+                    SELECT role, content, created_at
+                    FROM messages
+                    WHERE session_id = ?
+                    ORDER BY seq ASC
+                    """,
+                    (session_id,),
+                ).fetchall()
+            finally:
+                conn.close()
+
+        visible = _group_into_display_turns(rows)
+
+        total = len(visible)
+        offset = (page - 1) * page_size
+        page_items = list(reversed(visible))[offset: offset + page_size]
+        page_items = list(reversed(page_items))
+
+        return {
+            "messages": page_items,
+            "total": total,
+            "page": page,
+            "page_size": page_size,
+            "has_more": offset + page_size < total,
+        }
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Return basic stats keyed by channel_type, for monitoring."""
+        with self._lock:
+            conn = self._connect()
+            try:
+                total_sessions = conn.execute(
+                    "SELECT COUNT(*) FROM sessions"
+                ).fetchone()[0]
+                total_messages = conn.execute(
+                    "SELECT COUNT(*) FROM messages"
+                ).fetchone()[0]
+                by_channel = conn.execute(
+                    """
+                    SELECT channel_type, COUNT(*) as cnt
+                    FROM sessions
+                    GROUP BY channel_type
+                    ORDER BY cnt DESC
+                    """
+                ).fetchall()
+                return {
+                    "total_sessions": total_sessions,
+                    "total_messages": total_messages,
+                    "by_channel": {row[0] or "unknown": row[1] for row in by_channel},
+                }
+            finally:
+                conn.close()
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _init_db(self) -> None:
+        self._db_path.parent.mkdir(parents=True, exist_ok=True)
+        conn = self._connect()
+        try:
+            conn.executescript(_DDL)
+            conn.commit()
+            self._migrate(conn)
+        finally:
+            conn.close()
+
+    def _migrate(self, conn: sqlite3.Connection) -> None:
+        """Apply incremental schema migrations on existing databases."""
+        cols = {
+            row[1]
+            for row in conn.execute("PRAGMA table_info(sessions)").fetchall()
+        }
+        if "channel_type" not in cols:
+            try:
+                conn.execute(_MIGRATION_ADD_CHANNEL_TYPE)
+                conn.commit()
+                logger.info("[ConversationStore] Migrated: added channel_type column")
+            except Exception as e:
+                logger.warning(f"[ConversationStore] Migration failed: {e}")
+
+    def _connect(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(str(self._db_path), timeout=10)
+        conn.execute("PRAGMA journal_mode=WAL")
+        conn.execute("PRAGMA synchronous=NORMAL")
+        return conn
+
+
+# ---------------------------------------------------------------------------
+# Singleton
+# ---------------------------------------------------------------------------
+
+_store_instance: Optional[ConversationStore] = None
+_store_lock = threading.Lock()
+
+
+def get_conversation_store() -> ConversationStore:
+    """
+    Return the process-wide ConversationStore singleton.
+
+    Reuses the long-term memory database so the project stays with a single
+    SQLite file: ~/cow/memory/long-term/index.db
+    The conversation tables (sessions / messages) are separate from the
+    memory tables (memory_chunks / file_metadata) — no conflicts.
+    """
+    global _store_instance
+    if _store_instance is not None:
+        return _store_instance
+
+    with _store_lock:
+        if _store_instance is not None:
+            return _store_instance
+
+        try:
+            from agent.memory.config import get_default_memory_config
+            db_path = get_default_memory_config().get_db_path()
+        except Exception:
+            from common.utils import expand_path
+            db_path = Path(expand_path("~/cow")) / "memory" / "long-term" / "index.db"
+
+        _store_instance = ConversationStore(db_path)
+        logger.debug(f"[ConversationStore] Using shared DB at: {db_path}")
+        return _store_instance

agent/memory/storage.py

@@ -509,7 +509,7 @@ class MemoryStorage:
         """Destructor to ensure connection is closed"""
         try:
             self.close()
-        except:
+        except Exception:
             pass  # Ignore errors during cleanup
     
     # Helper methods

agent/protocol/agent_stream.py

@@ -501,7 +501,7 @@ class AgentStreamExecutor:
 
         # Prepare messages
         messages = self._prepare_messages()
-        logger.debug(f"Sending {len(messages)} messages to LLM")
+        logger.info(f"Sending {len(messages)} messages to LLM")
 
         # Prepare tool definitions (OpenAI/Claude format)
         tools_schema = None
@@ -574,7 +574,7 @@ class AgentStreamExecutor:
                         raise Exception(f"{error_msg} (Status: {status_code}, Code: {error_code}, Type: {error_type})")
 
                 # Parse chunk
-                if isinstance(chunk, dict) and "choices" in chunk:
+                if isinstance(chunk, dict) and chunk.get("choices"):
                     choice = chunk["choices"][0]
                     delta = choice.get("delta", {})
                     

agent/tools/ls/ls.py

@@ -94,7 +94,7 @@ class Ls(BaseTool):
                         results.append(entry + '/')
                     else:
                         results.append(entry)
-                except:
+                except Exception:
                     # Skip entries we can't stat
                     continue
             

agent/tools/scheduler/integration.py

@@ -451,8 +451,7 @@ def attach_scheduler_to_tool(tool, context: Context = None):
     if context:
         tool.current_context = context
         
-        # Also set channel_type from config
-        channel_type = conf().get("channel_type", "unknown")
+        channel_type = context.get("channel_type") or conf().get("channel_type", "unknown")
         if not tool.config:
             tool.config = {}
         tool.config["channel_type"] = channel_type

agent/tools/scheduler/scheduler_service.py

@@ -147,7 +147,7 @@ class SchedulerService:
                     return False
             
             return now >= next_run
-        except:
+        except Exception:
             return False
     
     def _calculate_next_run(self, task: dict, from_time: datetime) -> Optional[datetime]:
@@ -195,7 +195,7 @@ class SchedulerService:
                 # Only return if in the future
                 if run_at > from_time:
                     return run_at
-            except:
+            except Exception:
                 pass
             return None
         

agent/tools/scheduler/scheduler_tool.py

@@ -424,7 +424,7 @@ class SchedulerTool(BaseTool):
             try:
                 dt = datetime.fromisoformat(run_at)
                 return f"一次性 ({dt.strftime('%Y-%m-%d %H:%M')})"
-            except:
+            except Exception:
                 return "一次性"
         
         return "未知"
@@ -438,6 +438,6 @@ class SchedulerTool(BaseTool):
                     return msg.other_user_nickname or "群聊"
                 else:
                     return msg.from_user_nickname or "用户"
-        except:
+        except Exception:
             pass
         return "未知"

agent/tools/scheduler/task_store.py

@@ -72,7 +72,7 @@ class TaskStore:
                         with open(self.store_path, 'r') as src:
                             with open(backup_path, 'w') as dst:
                                 dst.write(src.read())
-                    except:
+                    except Exception:
                         pass
                 
                 # Save tasks

app.py

@@ -13,7 +13,6 @@ from plugins import *
 import threading
 
 
-# Global channel manager for restart support
 _channel_mgr = None
 
 
@@ -21,92 +20,159 @@ def get_channel_manager():
     return _channel_mgr
 
 
+def _parse_channel_type(raw) -> list:
+    """
+    Parse channel_type config value into a list of channel names.
+    Supports:
+      - single string: "feishu"
+      - comma-separated string: "feishu, dingtalk"
+      - list: ["feishu", "dingtalk"]
+    """
+    if isinstance(raw, list):
+        return [ch.strip() for ch in raw if ch.strip()]
+    if isinstance(raw, str):
+        return [ch.strip() for ch in raw.split(",") if ch.strip()]
+    return []
+
+
 class ChannelManager:
     """
-    Manage the lifecycle of a channel, supporting restart from sub-threads.
-    The channel.startup() runs in a daemon thread so that the main thread
-    remains available and a new channel can be started at any time.
+    Manage the lifecycle of multiple channels running concurrently.
+    Each channel.startup() runs in its own daemon thread.
+    The web channel is started as default console unless explicitly disabled.
     """
 
     def __init__(self):
-        self._channel = None
-        self._channel_thread = None
+        self._channels = {}        # channel_name -> channel instance
+        self._threads = {}         # channel_name -> thread
+        self._primary_channel = None
         self._lock = threading.Lock()
 
     @property
     def channel(self):
-        return self._channel
+        """Return the primary (first non-web) channel for backward compatibility."""
+        return self._primary_channel
 
-    def start(self, channel_name: str, first_start: bool = False):
+    def get_channel(self, channel_name: str):
+        return self._channels.get(channel_name)
+
+    def start(self, channel_names: list, first_start: bool = False):
         """
-        Create and start a channel in a sub-thread.
+        Create and start one or more channels in sub-threads.
         If first_start is True, plugins and linkai client will also be initialized.
         """
         with self._lock:
-            channel = channel_factory.create_channel(channel_name)
-            self._channel = channel
+            channels = []
+            for name in channel_names:
+                ch = channel_factory.create_channel(name)
+                self._channels[name] = ch
+                channels.append((name, ch))
+                if self._primary_channel is None and name != "web":
+                    self._primary_channel = ch
+
+            if self._primary_channel is None and channels:
+                self._primary_channel = channels[0][1]
 
             if first_start:
-                if channel_name in ["wx", "wxy", "terminal", "wechatmp", "web",
-                                    "wechatmp_service", "wechatcom_app", "wework",
-                                    const.FEISHU, const.DINGTALK]:
-                    PluginManager().load_plugins()
+                PluginManager().load_plugins()
 
                 if conf().get("use_linkai"):
                     try:
                         from common import cloud_client
-                        threading.Thread(target=cloud_client.start, args=(channel, self), daemon=True).start()
-                    except Exception as e:
+                        threading.Thread(
+                            target=cloud_client.start,
+                            args=(self._primary_channel, self),
+                            daemon=True,
+                        ).start()
+                    except Exception:
                         pass
 
-            # Run channel.startup() in a daemon thread so we can restart later
-            self._channel_thread = threading.Thread(
-                target=self._run_channel, args=(channel,), daemon=True
-            )
-            self._channel_thread.start()
-            logger.debug(f"[ChannelManager] Channel '{channel_name}' started in sub-thread")
+            # Start web console first so its logs print cleanly,
+            # then start remaining channels after a brief pause.
+            web_entry = None
+            other_entries = []
+            for entry in channels:
+                if entry[0] == "web":
+                    web_entry = entry
+                else:
+                    other_entries.append(entry)
 
-    def _run_channel(self, channel):
+            ordered = ([web_entry] if web_entry else []) + other_entries
+            for i, (name, ch) in enumerate(ordered):
+                if i > 0 and name != "web":
+                    time.sleep(0.1)
+                t = threading.Thread(target=self._run_channel, args=(name, ch), daemon=True)
+                self._threads[name] = t
+                t.start()
+                logger.debug(f"[ChannelManager] Channel '{name}' started in sub-thread")
+
+    def _run_channel(self, name: str, channel):
         try:
             channel.startup()
         except Exception as e:
-            logger.error(f"[ChannelManager] Channel startup error: {e}")
+            logger.error(f"[ChannelManager] Channel '{name}' startup error: {e}")
             logger.exception(e)
 
-    def stop(self):
+    def stop(self, channel_name: str = None):
         """
-        Stop the current channel. Since most channel startup() methods block
-        on an HTTP server or stream client, we stop by terminating the thread.
+        Stop channel(s). If channel_name is given, stop only that channel;
+        otherwise stop all channels.
         """
+        # Pop under lock, then stop outside lock to avoid deadlock
         with self._lock:
-            if self._channel is None:
-                return
-            channel_type = getattr(self._channel, 'channel_type', 'unknown')
-            logger.info(f"[ChannelManager] Stopping channel '{channel_type}'...")
+            names = [channel_name] if channel_name else list(self._channels.keys())
+            to_stop = []
+            for name in names:
+                ch = self._channels.pop(name, None)
+                th = self._threads.pop(name, None)
+                to_stop.append((name, ch, th))
+            if channel_name and self._primary_channel is self._channels.get(channel_name):
+                self._primary_channel = None
 
-            # Try graceful stop if channel implements it
+        for name, ch, th in to_stop:
+            if ch is None:
+                logger.warning(f"[ChannelManager] Channel '{name}' not found in managed channels")
+                if th and th.is_alive():
+                    self._interrupt_thread(th, name)
+                continue
+            logger.info(f"[ChannelManager] Stopping channel '{name}'...")
             try:
-                if hasattr(self._channel, 'stop'):
-                    self._channel.stop()
+                if hasattr(ch, 'stop'):
+                    ch.stop()
             except Exception as e:
-                logger.warning(f"[ChannelManager] Error during channel stop: {e}")
+                logger.warning(f"[ChannelManager] Error during channel '{name}' stop: {e}")
+            if th and th.is_alive():
+                self._interrupt_thread(th, name)
 
-            self._channel = None
-            self._channel_thread = None
+    @staticmethod
+    def _interrupt_thread(th: threading.Thread, name: str):
+        """Raise SystemExit in target thread to break blocking loops like start_forever."""
+        import ctypes
+        try:
+            tid = th.ident
+            if tid is None:
+                return
+            res = ctypes.pythonapi.PyThreadState_SetAsyncExc(
+                ctypes.c_ulong(tid), ctypes.py_object(SystemExit)
+            )
+            if res == 1:
+                logger.info(f"[ChannelManager] Interrupted thread for channel '{name}'")
+            elif res > 1:
+                ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_ulong(tid), None)
+                logger.warning(f"[ChannelManager] Failed to interrupt thread for channel '{name}'")
+        except Exception as e:
+            logger.warning(f"[ChannelManager] Thread interrupt error for '{name}': {e}")
 
     def restart(self, new_channel_name: str):
         """
-        Restart the channel with a new channel type.
+        Restart a single channel with a new channel type.
         Can be called from any thread (e.g. linkai config callback).
         """
         logger.info(f"[ChannelManager] Restarting channel to '{new_channel_name}'...")
-        self.stop()
-
-        # Clear singleton cache so a fresh channel instance is created
+        self.stop(new_channel_name)
         _clear_singleton_cache(new_channel_name)
-
-        time.sleep(1)  # Brief pause to allow resources to release
-        self.start(new_channel_name, first_start=False)
+        time.sleep(1)
+        self.start([new_channel_name], first_start=False)
         logger.info(f"[ChannelManager] Channel restarted to '{new_channel_name}' successfully")
 
 
@@ -130,14 +196,11 @@ def _clear_singleton_cache(channel_name: str):
     module_path = cls_map.get(channel_name)
     if not module_path:
         return
-    # The singleton decorator stores instances in a closure dict keyed by class.
-    # We need to find the actual class and clear it from the closure.
     try:
         parts = module_path.rsplit(".", 1)
         module_name, class_name = parts[0], parts[1]
         import importlib
         module = importlib.import_module(module_name)
-        # The module-level name is the wrapper function from @singleton
         wrapper = getattr(module, class_name, None)
         if wrapper and hasattr(wrapper, '__closure__') and wrapper.__closure__:
             for cell in wrapper.__closure__:
@@ -176,17 +239,28 @@ def run():
         # kill signal
         sigterm_handler_wrap(signal.SIGTERM)
 
-        # create channel
-        channel_name = conf().get("channel_type", "wx")
+        # Parse channel_type into a list
+        raw_channel = conf().get("channel_type", "web")
 
         if "--cmd" in sys.argv:
-            channel_name = "terminal"
+            channel_names = ["terminal"]
+        else:
+            channel_names = _parse_channel_type(raw_channel)
+            if not channel_names:
+                channel_names = ["web"]
 
-        if channel_name == "wxy":
+        if "wxy" in channel_names:
             os.environ["WECHATY_LOG"] = "warn"
 
+        # Auto-start web console unless explicitly disabled
+        web_console_enabled = conf().get("web_console", True)
+        if web_console_enabled and "web" not in channel_names:
+            channel_names.append("web")
+
+        logger.info(f"[App] Starting channels: {channel_names}")
+
         _channel_mgr = ChannelManager()
-        _channel_mgr.start(channel_name, first_start=True)
+        _channel_mgr.start(channel_names, first_start=True)
 
         while True:
             time.sleep(1)

bridge/agent_bridge.py

@@ -65,30 +65,67 @@ class AgentLLMModel(LLMModel):
     LLM Model adapter that uses COW's existing bot infrastructure
     """
 
+    _MODEL_BOT_TYPE_MAP = {
+        "wenxin": const.BAIDU, "wenxin-4": const.BAIDU,
+        "xunfei": const.XUNFEI, const.QWEN: const.QWEN,
+        const.MODELSCOPE: const.MODELSCOPE,
+    }
+    _MODEL_PREFIX_MAP = [
+        ("qwen", const.QWEN_DASHSCOPE), ("qwq", const.QWEN_DASHSCOPE), ("qvq", const.QWEN_DASHSCOPE),
+        ("gemini", const.GEMINI), ("glm", const.ZHIPU_AI), ("claude", const.CLAUDEAPI),
+        ("moonshot", const.MOONSHOT), ("kimi", const.MOONSHOT),
+        ("doubao", const.DOUBAO),
+    ]
+
     def __init__(self, bridge: Bridge, bot_type: str = "chat"):
-        # Get model name directly from config
         from config import conf
-        model_name = conf().get("model", const.GPT_41)
-        super().__init__(model=model_name)
+        super().__init__(model=conf().get("model", const.GPT_41))
         self.bridge = bridge
         self.bot_type = bot_type
         self._bot = None
-        self._use_linkai = conf().get("use_linkai", False) and conf().get("linkai_api_key")
-    
+        self._bot_model = None
+
+    @property
+    def model(self):
+        from config import conf
+        return conf().get("model", const.GPT_41)
+
+    @model.setter
+    def model(self, value):
+        pass
+
+    def _resolve_bot_type(self, model_name: str) -> str:
+        """Resolve bot type from model name, matching Bridge.__init__ logic."""
+        from config import conf
+        if conf().get("use_linkai", False) and conf().get("linkai_api_key"):
+            return const.LINKAI
+        if not model_name or not isinstance(model_name, str):
+            return const.CHATGPT
+        if model_name in self._MODEL_BOT_TYPE_MAP:
+            return self._MODEL_BOT_TYPE_MAP[model_name]
+        if model_name.lower().startswith("minimax") or model_name in ["abab6.5-chat"]:
+            return const.MiniMax
+        if model_name in [const.QWEN_TURBO, const.QWEN_PLUS, const.QWEN_MAX]:
+            return const.QWEN_DASHSCOPE
+        if model_name in [const.MOONSHOT, "moonshot-v1-8k", "moonshot-v1-32k", "moonshot-v1-128k"]:
+            return const.MOONSHOT
+        if model_name in [const.DEEPSEEK_CHAT, const.DEEPSEEK_REASONER]:
+            return const.CHATGPT
+        for prefix, btype in self._MODEL_PREFIX_MAP:
+            if model_name.startswith(prefix):
+                return btype
+        return const.CHATGPT
+
     @property
     def bot(self):
-        """Lazy load the bot and enhance it with tool calling if needed"""
-        if self._bot is None:
-            # If use_linkai is enabled, use LinkAI bot directly
-            if self._use_linkai:
-                self._bot = self.bridge.find_chat_bot(const.LINKAI)
-            else:
-                self._bot = self.bridge.get_bot(self.bot_type)
-                # Automatically add tool calling support if not present
-                self._bot = add_openai_compatible_support(self._bot)
-            
-            # Log bot info
-            bot_name = type(self._bot).__name__
+        """Lazy load the bot, re-create when model changes"""
+        from models.bot_factory import create_bot
+        cur_model = self.model
+        if self._bot is None or self._bot_model != cur_model:
+            bot_type = self._resolve_bot_type(cur_model)
+            self._bot = create_bot(bot_type)
+            self._bot = add_openai_compatible_support(self._bot)
+            self._bot_model = cur_model
         return self._bot
 
     def call(self, request: LLMRequest):
@@ -135,7 +172,7 @@ class AgentLLMModel(LLMModel):
                 # Use tool-enabled streaming call if available
                 # Extract system prompt if present
                 system_prompt = getattr(request, 'system', None)
-                
+
                 # Build kwargs for call_with_tools
                 kwargs = {
                     'messages': request.messages,
@@ -143,15 +180,20 @@ class AgentLLMModel(LLMModel):
                     'stream': True,
                     'model': self.model  # Pass model parameter
                 }
-                
+
                 # Only pass max_tokens if explicitly set, let the bot use its default
                 if request.max_tokens is not None:
                     kwargs['max_tokens'] = request.max_tokens
-                
+
                 # Add system prompt if present
                 if system_prompt:
                     kwargs['system'] = system_prompt
-                
+
+                # Pass channel_type for linkai tracking
+                channel_type = getattr(self, 'channel_type', None)
+                if channel_type:
+                    kwargs['channel_type'] = channel_type
+
                 stream = self.bot.call_with_tools(**kwargs)
                 
                 # Convert stream format to our expected format
@@ -325,6 +367,14 @@ class AgentBridge:
                                 logger.warning(f"[AgentBridge] Failed to attach context to scheduler: {e}")
                             break
             
+            # Pass channel_type to model so linkai requests carry it
+            if context and hasattr(agent, 'model'):
+                agent.model.channel_type = context.get("channel_type", "")
+
+            # Record message count before execution so we can diff new messages
+            with agent.messages_lock:
+                pre_run_len = len(agent.messages)
+
             try:
                 # Use agent's run_stream method with event handler
                 response = agent.run_stream(
@@ -336,9 +386,16 @@ class AgentBridge:
                 # Restore original tools
                 if context and context.get("is_scheduled_task"):
                     agent.tools = original_tools
-                
+
                 # Log execution summary
                 event_handler.log_summary()
+
+            # Persist new messages generated during this run
+            if session_id:
+                channel_type = (context.get("channel_type") or "") if context else ""
+                with agent.messages_lock:
+                    new_messages = agent.messages[pre_run_len:]
+                self._persist_messages(session_id, list(new_messages), channel_type)
             
             # Check if there are files to send (from read tool)
             if hasattr(agent, 'stream_executor') and hasattr(agent.stream_executor, 'files_to_send'):
@@ -475,6 +532,32 @@ class AgentBridge:
             except Exception as e:
                 logger.warning(f"[AgentBridge] Failed to migrate API keys: {e}")
     
+    def _persist_messages(
+        self, session_id: str, new_messages: list, channel_type: str = ""
+    ) -> None:
+        """
+        Persist new messages to the conversation store after each agent run.
+
+        Failures are logged but never propagate — they must not interrupt replies.
+        """
+        if not new_messages:
+            return
+        try:
+            from config import conf
+            if not conf().get("conversation_persistence", True):
+                return
+        except Exception:
+            pass
+        try:
+            from agent.memory import get_conversation_store
+            get_conversation_store().append_messages(
+                session_id, new_messages, channel_type=channel_type
+            )
+        except Exception as e:
+            logger.warning(
+                f"[AgentBridge] Failed to persist messages for session={session_id}: {e}"
+            )
+
     def clear_session(self, session_id: str):
         """
         Clear a specific session's agent and conversation history

bridge/agent_event_handler.py

@@ -94,15 +94,15 @@ class AgentEventHandler:
     
     def _send_to_channel(self, message):
         """
-        Try to send message to channel
-        
-        Args:
-            message: Message to send
+        Try to send intermediate message to channel.
+        Skipped in SSE mode because thinking text is already streamed via on_event.
         """
+        if self.context and self.context.get("on_event"):
+            return
+
         if self.channel:
             try:
                 from bridge.reply import Reply, ReplyType
-                # Create a Reply object for the message
                 reply = Reply(ReplyType.TEXT, message)
                 self.channel._send(reply, self.context)
             except Exception as e:

bridge/agent_initializer.py

@@ -118,8 +118,47 @@ class AgentInitializer:
         # Attach memory manager
         if memory_manager:
             agent.memory_manager = memory_manager
-        
+
+        # Restore persisted conversation history for this session
+        if session_id:
+            self._restore_conversation_history(agent, session_id)
+
         return agent
+
+    def _restore_conversation_history(self, agent, session_id: str) -> None:
+        """
+        Load persisted conversation messages from SQLite and inject them
+        into the agent's in-memory message list.
+
+        Only runs when conversation persistence is enabled (default: True).
+        Respects agent_max_context_turns to limit how many turns are loaded.
+        """
+        from config import conf
+        if not conf().get("conversation_persistence", True):
+            return
+
+        try:
+            from agent.memory import get_conversation_store
+            store = get_conversation_store()
+            # On restore, load at most min(10, max_turns // 2) turns so that
+            # a long-running session does not immediately fill the context window
+            # after a restart.  The full max_turns budget is reserved for the
+            # live conversation that follows.
+            max_turns = conf().get("agent_max_context_turns", 30)
+            restore_turns = max(4, max_turns // 5)
+            saved = store.load_messages(session_id, max_turns=restore_turns)
+            if saved:
+                with agent.messages_lock:
+                    agent.messages = saved
+                logger.debug(
+                    f"[AgentInitializer] Restored {len(saved)} messages "
+                    f"({restore_turns} turns cap) for session={session_id}"
+                )
+        except Exception as e:
+            logger.warning(
+                f"[AgentInitializer] Failed to restore conversation history for "
+                f"session={session_id}: {e}"
+            )
     
     def _load_env_file(self):
         """Load environment variables from .env file"""
@@ -283,7 +322,14 @@ class AgentInitializer:
                         tool.scheduler_service = scheduler_service
                         if not tool.config:
                             tool.config = {}
-                        tool.config["channel_type"] = conf().get("channel_type", "unknown")
+                        raw_ct = conf().get("channel_type", "unknown")
+                        if isinstance(raw_ct, list):
+                            ct = raw_ct[0] if raw_ct else "unknown"
+                        elif isinstance(raw_ct, str) and "," in raw_ct:
+                            ct = raw_ct.split(",")[0].strip()
+                        else:
+                            ct = raw_ct
+                        tool.config["channel_type"] = ct
             except Exception as e:
                 logger.warning(f"[AgentInitializer] Failed to inject scheduler dependencies: {e}")
     
@@ -330,7 +376,7 @@ class AgentInitializer:
         return {
             "model": conf().get("model", "unknown"),
             "workspace": workspace_root,
-            "channel": conf().get("channel_type", "unknown"),
+            "channel": ", ".join(conf().get("channel_type")) if isinstance(conf().get("channel_type"), list) else conf().get("channel_type", "unknown"),
             "_get_current_time": get_current_time  # Dynamic time function
         }
     

channel/channel.py

@@ -57,11 +57,14 @@ class Channel(object):
                 if context and "channel_type" not in context:
                     context["channel_type"] = self.channel_type
 
+                # Read on_event callback injected by the channel (e.g. web SSE)
+                on_event = context.get("on_event") if context else None
+
                 # Use agent bridge to handle the query
                 return Bridge().fetch_agent_reply(
                     query=query,
                     context=context,
-                    on_event=None,
+                    on_event=on_event,
                     clear_history=False
                 )
             except Exception as e:

channel/chat_channel.py

@@ -24,11 +24,16 @@ handler_pool = ThreadPoolExecutor(max_workers=8)  # 处理消息的线程池
 class ChatChannel(Channel):
     name = None  # 登录的用户名
     user_id = None  # 登录的用户id
-    futures = {}  # 记录每个session_id提交到线程池的future对象, 用于重置会话时把没执行的future取消掉，正在执行的不会被取消
-    sessions = {}  # 用于控制并发，每个session_id同时只能有一个context在处理
-    lock = threading.Lock()  # 用于控制对sessions的访问
 
     def __init__(self):
+        # Instance-level attributes so each channel subclass has its own
+        # independent session queue and lock. Previously these were class-level,
+        # which caused contexts from one channel (e.g. Feishu) to be consumed
+        # by another channel's consume() thread (e.g. Web), leading to errors
+        # like "No request_id found in context".
+        self.futures = {}
+        self.sessions = {}
+        self.lock = threading.Lock()
         _thread = threading.Thread(target=self.consume)
         _thread.setDaemon(True)
         _thread.start()
@@ -37,9 +42,8 @@ class ChatChannel(Channel):
     def _compose_context(self, ctype: ContextType, content, **kwargs):
         context = Context(ctype, content)
         context.kwargs = kwargs
-        # context首次传入时，origin_ctype是None,
-        # 引入的起因是：当输入语音时，会嵌套生成两个context，第一步语音转文本，第二步通过文本生成文字回复。
-        # origin_ctype用于第二步文本回复时，判断是否需要匹配前缀，如果是私聊的语音，就不需要匹配前缀
+        if "channel_type" not in context:
+            context["channel_type"] = self.channel_type
         if "origin_ctype" not in context:
             context["origin_ctype"] = ctype
         # context首次传入时，receiver是None，根据类型设置receiver

channel/dingtalk/dingtalk_channel.py

@@ -101,6 +101,8 @@ class DingTalkChanel(ChatChannel, dingtalk_stream.ChatbotHandler):
         # 历史消息id暂存，用于幂等控制
         self.receivedMsgs = ExpiredDict(conf().get("expires_in_seconds", 3600))
         self._stream_client = None
+        self._running = False
+        self._event_loop = None
         logger.debug("[DingTalk] client_id={}, client_secret={} ".format(
             self.dingtalk_client_id, self.dingtalk_client_secret))
         # 无需群校验和前缀
@@ -114,21 +116,54 @@ class DingTalkChanel(ChatChannel, dingtalk_stream.ChatbotHandler):
         self._robot_code = None
 
     def startup(self):
+        import asyncio
+        self.dingtalk_client_id = conf().get('dingtalk_client_id')
+        self.dingtalk_client_secret = conf().get('dingtalk_client_secret')
+        self._running = True
         credential = dingtalk_stream.Credential(self.dingtalk_client_id, self.dingtalk_client_secret)
         client = dingtalk_stream.DingTalkStreamClient(credential)
         self._stream_client = client
         client.register_callback_handler(dingtalk_stream.chatbot.ChatbotMessage.TOPIC, self)
-        logger.info("[DingTalk] ✅ Stream connected, ready to receive messages")
-        client.start_forever()
+        logger.info("[DingTalk] ✅ Stream client initialized, ready to receive messages")
+        _first_connect = True
+        while self._running:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            self._event_loop = loop
+            try:
+                if not _first_connect:
+                    logger.info("[DingTalk] Reconnecting...")
+                _first_connect = False
+                loop.run_until_complete(client.start())
+            except (KeyboardInterrupt, SystemExit):
+                logger.info("[DingTalk] Startup loop received stop signal, exiting")
+                break
+            except Exception as e:
+                if not self._running:
+                    break
+                logger.warning(f"[DingTalk] Stream connection error: {e}, reconnecting in 3s...")
+                time.sleep(3)
+            finally:
+                self._event_loop = None
+                try:
+                    loop.close()
+                except Exception:
+                    pass
+        logger.info("[DingTalk] Startup loop exited")
 
     def stop(self):
-        if self._stream_client:
+        import asyncio
+        logger.info("[DingTalk] stop() called, setting _running=False")
+        self._running = False
+        loop = self._event_loop
+        if loop and not loop.is_closed():
             try:
-                self._stream_client.stop()
-                logger.info("[DingTalk] Stream client stopped")
+                loop.call_soon_threadsafe(loop.stop)
+                logger.info("[DingTalk] Sent stop signal to event loop")
             except Exception as e:
-                logger.warning(f"[DingTalk] Error stopping stream client: {e}")
-            self._stream_client = None
+                logger.warning(f"[DingTalk] Error stopping event loop: {e}")
+        self._stream_client = None
+        logger.info("[DingTalk] stop() completed")
     
     def get_access_token(self):
         """
@@ -465,23 +500,21 @@ class DingTalkChanel(ChatChannel, dingtalk_stream.ChatbotHandler):
     async def process(self, callback: dingtalk_stream.CallbackMessage):
         try:
             incoming_message = dingtalk_stream.ChatbotMessage.from_dict(callback.data)
-            
+
             # 缓存 robot_code，用于后续图片下载
             if hasattr(incoming_message, 'robot_code'):
                 self._robot_code_cache = incoming_message.robot_code
-            
-            # Debug: 打印完整的 event 数据
-            logger.debug(f"[DingTalk] ===== Incoming Message Debug =====")
-            logger.debug(f"[DingTalk] callback.data keys: {callback.data.keys() if hasattr(callback.data, 'keys') else 'N/A'}")
-            logger.debug(f"[DingTalk] incoming_message attributes: {dir(incoming_message)}")
-            logger.debug(f"[DingTalk] robot_code: {getattr(incoming_message, 'robot_code', 'N/A')}")
-            logger.debug(f"[DingTalk] chatbot_corp_id: {getattr(incoming_message, 'chatbot_corp_id', 'N/A')}")
-            logger.debug(f"[DingTalk] chatbot_user_id: {getattr(incoming_message, 'chatbot_user_id', 'N/A')}")
-            logger.debug(f"[DingTalk] conversation_id: {getattr(incoming_message, 'conversation_id', 'N/A')}")
-            logger.debug(f"[DingTalk] Raw callback.data: {callback.data}")
-            logger.debug(f"[DingTalk] =====================================")
-            
-            image_download_handler = self  # 传入方法所在的类实例
+
+            # Filter out stale messages from before channel startup (offline backlog)
+            create_at = getattr(incoming_message, 'create_at', None)
+            if create_at:
+                msg_age_s = time.time() - int(create_at) / 1000
+                if msg_age_s > 60:
+                    logger.warning(f"[DingTalk] stale msg filtered (age={msg_age_s:.0f}s), "
+                                   f"msg_id={getattr(incoming_message, 'message_id', 'N/A')}")
+                    return AckMessage.STATUS_OK, 'OK'
+
+            image_download_handler = self
             dingtalk_msg = DingTalkMessage(incoming_message, image_download_handler)
 
             if dingtalk_msg.is_group:
@@ -490,8 +523,7 @@ class DingTalkChanel(ChatChannel, dingtalk_stream.ChatbotHandler):
                 self.handle_single(dingtalk_msg)
             return AckMessage.STATUS_OK, 'OK'
         except Exception as e:
-            logger.error(f"[DingTalk] process error: {e}")
-            logger.exception(e)  # 打印完整堆栈跟踪
+            logger.error(f"[DingTalk] process error: {e}", exc_info=True)
             return AckMessage.STATUS_SYSTEM_EXCEPTION, 'ERROR'
 
     @time_checker

channel/feishu/feishu_channel.py

@@ -61,6 +61,8 @@ class FeiShuChanel(ChatChannel):
         # 历史消息id暂存，用于幂等控制
         self.receivedMsgs = ExpiredDict(60 * 60 * 7.1)
         self._http_server = None
+        self._ws_client = None
+        self._ws_thread = None
         logger.debug("[FeiShu] app_id={}, app_secret={}, verification_token={}, event_mode={}".format(
             self.feishu_app_id, self.feishu_app_secret, self.feishu_token, self.feishu_event_mode))
         # 无需群校验和前缀
@@ -73,12 +75,37 @@ class FeiShuChanel(ChatChannel):
             raise Exception("lark_oapi not installed")
 
     def startup(self):
+        self.feishu_app_id = conf().get('feishu_app_id')
+        self.feishu_app_secret = conf().get('feishu_app_secret')
+        self.feishu_token = conf().get('feishu_token')
+        self.feishu_event_mode = conf().get('feishu_event_mode', 'websocket')
         if self.feishu_event_mode == 'websocket':
             self._startup_websocket()
         else:
             self._startup_webhook()
 
     def stop(self):
+        import ctypes
+        logger.info("[FeiShu] stop() called")
+        ws_client = self._ws_client
+        self._ws_client = None
+        ws_thread = self._ws_thread
+        self._ws_thread = None
+        # Interrupt the ws thread first so its blocking start() unblocks
+        if ws_thread and ws_thread.is_alive():
+            try:
+                tid = ws_thread.ident
+                if tid:
+                    res = ctypes.pythonapi.PyThreadState_SetAsyncExc(
+                        ctypes.c_ulong(tid), ctypes.py_object(SystemExit)
+                    )
+                    if res == 1:
+                        logger.info("[FeiShu] Interrupted ws thread via ctypes")
+                    elif res > 1:
+                        ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_ulong(tid), None)
+            except Exception as e:
+                logger.warning(f"[FeiShu] Error interrupting ws thread: {e}")
+        # lark.ws.Client has no stop() method; thread interruption above is sufficient
         if self._http_server:
             try:
                 self._http_server.stop()
@@ -86,6 +113,7 @@ class FeiShuChanel(ChatChannel):
             except Exception as e:
                 logger.warning(f"[FeiShu] Error stopping HTTP server: {e}")
             self._http_server = None
+        logger.info("[FeiShu] stop() completed")
 
     def _startup_webhook(self):
         """启动HTTP服务器接收事件(webhook模式)"""
@@ -129,29 +157,26 @@ class FeiShuChanel(ChatChannel):
             .register_p2_im_message_receive_v1(handle_message_event) \
             .build()
 
-        # 尝试连接，如果遇到SSL错误则自动禁用证书验证
         def start_client_with_retry():
-            """启动websocket客户端，自动处理SSL证书错误"""
-            # 全局禁用SSL证书验证（在导入lark_oapi之前设置）
+            """Run ws client in this thread with its own event loop to avoid conflicts."""
+            import asyncio
             import ssl as ssl_module
-
-            # 保存原始的SSL上下文创建方法
             original_create_default_context = ssl_module.create_default_context
 
             def create_unverified_context(*args, **kwargs):
-                """创建一个不验证证书的SSL上下文"""
                 context = original_create_default_context(*args, **kwargs)
                 context.check_hostname = False
                 context.verify_mode = ssl.CERT_NONE
                 return context
 
-            # 尝试正常连接，如果失败则禁用SSL验证
+            # Give this thread its own event loop so lark SDK can call run_until_complete
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
             for attempt in range(2):
                 try:
                     if attempt == 1:
-                        # 第二次尝试：禁用SSL验证
-                        logger.warning("[FeiShu] SSL certificate verification disabled due to certificate error. "
-                                       "This may happen when using corporate proxy or self-signed certificates.")
+                        logger.warning("[FeiShu] Retrying with SSL verification disabled...")
                         ssl_module.create_default_context = create_unverified_context
                         ssl_module._create_unverified_context = create_unverified_context
 
@@ -159,39 +184,36 @@ class FeiShuChanel(ChatChannel):
                         self.feishu_app_id,
                         self.feishu_app_secret,
                         event_handler=event_handler,
-                        log_level=lark.LogLevel.DEBUG if conf().get("debug") else lark.LogLevel.WARNING
+                        log_level=lark.LogLevel.WARNING
                     )
-
+                    self._ws_client = ws_client
                     logger.debug("[FeiShu] Websocket client starting...")
                     ws_client.start()
-                    # 如果成功启动，跳出循环
                     break
 
+                except (SystemExit, KeyboardInterrupt):
+                    logger.info("[FeiShu] Websocket thread received stop signal")
+                    break
                 except Exception as e:
                     error_msg = str(e)
-                    # 检查是否是SSL证书验证错误
-                    is_ssl_error = "CERTIFICATE_VERIFY_FAILED" in error_msg or "certificate verify failed" in error_msg.lower()
-
+                    is_ssl_error = ("CERTIFICATE_VERIFY_FAILED" in error_msg
+                                    or "certificate verify failed" in error_msg.lower())
                     if is_ssl_error and attempt == 0:
-                        # 第一次遇到SSL错误，记录日志并继续循环（下次会禁用验证）
-                        logger.warning(f"[FeiShu] SSL certificate verification failed: {error_msg}")
-                        logger.info("[FeiShu] Retrying connection with SSL verification disabled...")
+                        logger.warning(f"[FeiShu] SSL error: {error_msg}, retrying...")
                         continue
-                    else:
-                        # 其他错误或禁用验证后仍失败，抛出异常
-                        logger.error(f"[FeiShu] Websocket client error: {e}", exc_info=True)
-                        # 恢复原始方法
-                        ssl_module.create_default_context = original_create_default_context
-                        raise
+                    logger.error(f"[FeiShu] Websocket client error: {e}", exc_info=True)
+                    ssl_module.create_default_context = original_create_default_context
+                    break
+            try:
+                loop.close()
+            except Exception:
+                pass
+            logger.info("[FeiShu] Websocket thread exited")
 
-            # 注意：不恢复原始方法，因为ws_client.start()会持续运行
-
-        # 在新线程中启动客户端，避免阻塞主线程
         ws_thread = threading.Thread(target=start_client_with_retry, daemon=True)
+        self._ws_thread = ws_thread
         ws_thread.start()
-
-        # 保持主线程运行
-        logger.info("[FeiShu] ✅ Websocket connected, ready to receive messages")
+        logger.info("[FeiShu] ✅ Websocket thread started, ready to receive messages")
         ws_thread.join()
 
     def _handle_message_event(self, event: dict):
@@ -212,6 +234,15 @@ class FeiShuChanel(ChatChannel):
             return
         self.receivedMsgs[msg_id] = True
 
+        # Filter out stale messages from before channel startup (offline backlog)
+        import time as _time
+        create_time_ms = msg.get("create_time")
+        if create_time_ms:
+            msg_age_s = _time.time() - int(create_time_ms) / 1000
+            if msg_age_s > 60:
+                logger.warning(f"[FeiShu] stale msg filtered (age={msg_age_s:.0f}s), msg_id={msg_id}")
+                return
+
         is_group = False
         chat_type = msg.get("chat_type")
 
@@ -698,6 +729,8 @@ class FeiShuChanel(ChatChannel):
     def _compose_context(self, ctype: ContextType, content, **kwargs):
         context = Context(ctype, content)
         context.kwargs = kwargs
+        if "channel_type" not in context:
+            context["channel_type"] = self.channel_type
         if "origin_ctype" not in context:
             context["origin_ctype"] = ctype
 

channel/web/static/css/console.css

@@ -0,0 +1,354 @@
+/* =====================================================================
+   CowAgent Console Styles
+   ===================================================================== */
+
+/* Animations */
+@keyframes pulseDot {
+    0%, 80%, 100% { transform: scale(0.6); opacity: 0.4; }
+    40% { transform: scale(1); opacity: 1; }
+}
+
+/* Scrollbar */
+* { scrollbar-width: thin; scrollbar-color: #94a3b8 transparent; }
+::-webkit-scrollbar { width: 6px; height: 6px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { background: #94a3b8; border-radius: 3px; }
+::-webkit-scrollbar-thumb:hover { background: #64748b; }
+.dark ::-webkit-scrollbar-thumb { background: #475569; }
+.dark ::-webkit-scrollbar-thumb:hover { background: #64748b; }
+
+/* Sidebar */
+.sidebar-item.active {
+    background: rgba(255, 255, 255, 0.08);
+    color: #FFFFFF;
+}
+.sidebar-item.active .item-icon { color: #4ABE6E; }
+
+/* Menu Groups */
+.menu-group-items { max-height: 0; overflow: hidden; transition: max-height 0.25s ease-out; }
+.menu-group.open .menu-group-items { max-height: 500px; transition: max-height 0.35s ease-in; }
+.menu-group .chevron { transition: transform 0.25s ease; }
+.menu-group.open .chevron { transform: rotate(90deg); }
+
+/* View Switching */
+.view { display: none; height: 100%; }
+.view.active { display: flex; flex-direction: column; }
+
+/* Markdown Content */
+.msg-content p { margin: 0.5em 0; line-height: 1.7; }
+.msg-content p:first-child { margin-top: 0; }
+.msg-content p:last-child { margin-bottom: 0; }
+.msg-content h1, .msg-content h2, .msg-content h3,
+.msg-content h4, .msg-content h5, .msg-content h6 {
+    margin-top: 1.2em; margin-bottom: 0.6em; font-weight: 600; line-height: 1.3;
+}
+.msg-content h1 { font-size: 1.4em; }
+.msg-content h2 { font-size: 1.25em; }
+.msg-content h3 { font-size: 1.1em; }
+.msg-content ul, .msg-content ol { margin: 0.5em 0; padding-left: 1.8em; }
+.msg-content li { margin: 0.25em 0; }
+.msg-content pre {
+    border-radius: 8px; overflow-x: auto; margin: 0.8em 0;
+    background: #f1f5f9; padding: 1em;
+}
+.dark .msg-content pre { background: #111111; }
+.msg-content code {
+    font-family: 'JetBrains Mono', 'Fira Code', Consolas, monospace;
+    font-size: 0.875em;
+}
+.msg-content :not(pre) > code {
+    background: rgba(74, 190, 110, 0.1); color: #1C6B3B;
+    padding: 2px 6px; border-radius: 4px;
+}
+.dark .msg-content :not(pre) > code {
+    background: rgba(74, 190, 110, 0.15); color: #74E9A4;
+}
+.msg-content pre code { background: transparent; padding: 0; color: inherit; }
+.msg-content blockquote {
+    border-left: 3px solid #4ABE6E; padding: 0.5em 1em;
+    margin: 0.8em 0; background: rgba(74, 190, 110, 0.05); border-radius: 0 6px 6px 0;
+}
+.dark .msg-content blockquote { background: rgba(74, 190, 110, 0.08); }
+.msg-content table { border-collapse: collapse; width: 100%; margin: 0.8em 0; }
+.msg-content th, .msg-content td {
+    border: 1px solid #e2e8f0; padding: 8px 12px; text-align: left;
+}
+.dark .msg-content th, .dark .msg-content td { border-color: rgba(255,255,255,0.1); }
+.msg-content th { background: #f1f5f9; font-weight: 600; }
+.dark .msg-content th { background: #111111; }
+.msg-content img { max-width: 100%; height: auto; border-radius: 8px; margin: 0.5em 0; }
+.msg-content a { color: #35A85B; text-decoration: underline; }
+.msg-content a:hover { color: #228547; }
+.msg-content hr { border: none; height: 1px; background: #e2e8f0; margin: 1.2em 0; }
+.dark .msg-content hr { background: rgba(255,255,255,0.1); }
+
+/* SSE Streaming cursor */
+@keyframes blink { 0%, 100% { opacity: 1; } 50% { opacity: 0; } }
+.sse-streaming::after {
+    content: '▋';
+    display: inline-block;
+    margin-left: 2px;
+    color: #4ABE6E;
+    animation: blink 0.9s step-end infinite;
+    font-size: 0.85em;
+    vertical-align: middle;
+}
+
+/* Agent steps (thinking summaries + tool indicators) */
+.agent-steps:empty { display: none; }
+.agent-steps:not(:empty) {
+    margin-bottom: 0.625rem;
+    padding-bottom: 0.5rem;
+    border-bottom: 1px dashed rgba(0, 0, 0, 0.08);
+}
+.dark .agent-steps:not(:empty) { border-bottom-color: rgba(255, 255, 255, 0.08); }
+
+.agent-step {
+    font-size: 0.75rem;
+    line-height: 1.4;
+    color: #94a3b8;
+    margin-bottom: 0.25rem;
+}
+.agent-step:last-child { margin-bottom: 0; }
+
+/* Thinking step - collapsible */
+.agent-thinking-step .thinking-header {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    cursor: pointer;
+    user-select: none;
+}
+.agent-thinking-step .thinking-header.no-toggle { cursor: default; }
+.agent-thinking-step .thinking-header:not(.no-toggle):hover { color: #64748b; }
+.dark .agent-thinking-step .thinking-header:not(.no-toggle):hover { color: #cbd5e1; }
+.agent-thinking-step .thinking-header i:first-child { font-size: 0.625rem; margin-top: 1px; }
+.agent-thinking-step .thinking-chevron {
+    font-size: 0.5rem;
+    margin-left: auto;
+    transition: transform 0.2s ease;
+    opacity: 0.5;
+}
+.agent-thinking-step.expanded .thinking-chevron { transform: rotate(90deg); }
+.agent-thinking-step .thinking-full {
+    display: none;
+    margin-top: 0.375rem;
+    margin-left: 1rem;
+    padding: 0.5rem;
+    background: rgba(0, 0, 0, 0.02);
+    border-radius: 6px;
+    border: 1px solid rgba(0, 0, 0, 0.04);
+    font-size: 0.75rem;
+    line-height: 1.5;
+    color: #94a3b8;
+    max-height: 200px;
+    overflow-y: auto;
+}
+.dark .agent-thinking-step .thinking-full {
+    background: rgba(255, 255, 255, 0.02);
+    border-color: rgba(255, 255, 255, 0.04);
+}
+.agent-thinking-step.expanded .thinking-full { display: block; }
+.agent-thinking-step .thinking-full p { margin: 0.25em 0; }
+.agent-thinking-step .thinking-full p:first-child { margin-top: 0; }
+.agent-thinking-step .thinking-full p:last-child { margin-bottom: 0; }
+
+/* Tool step - collapsible */
+.agent-tool-step .tool-header {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    cursor: pointer;
+    user-select: none;
+    padding: 1px 0;
+    border-radius: 4px;
+}
+.agent-tool-step .tool-header:hover { color: #64748b; }
+.dark .agent-tool-step .tool-header:hover { color: #cbd5e1; }
+.agent-tool-step .tool-icon { font-size: 0.625rem; }
+.agent-tool-step .tool-chevron {
+    font-size: 0.5rem;
+    margin-left: auto;
+    transition: transform 0.2s ease;
+    opacity: 0.5;
+}
+.agent-tool-step.expanded .tool-chevron { transform: rotate(90deg); }
+.agent-tool-step .tool-time {
+    font-size: 0.65rem;
+    opacity: 0.6;
+    margin-left: 0.25rem;
+}
+
+/* Tool detail panel */
+.agent-tool-step .tool-detail {
+    display: none;
+    margin-top: 0.375rem;
+    margin-left: 1rem;
+    padding: 0.5rem;
+    background: rgba(0, 0, 0, 0.02);
+    border-radius: 6px;
+    border: 1px solid rgba(0, 0, 0, 0.04);
+}
+.dark .agent-tool-step .tool-detail {
+    background: rgba(255, 255, 255, 0.02);
+    border-color: rgba(255, 255, 255, 0.04);
+}
+.agent-tool-step.expanded .tool-detail { display: block; }
+.tool-detail-section { margin-bottom: 0.375rem; }
+.tool-detail-section:last-child { margin-bottom: 0; }
+.tool-detail-label {
+    font-size: 0.625rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    opacity: 0.6;
+    margin-bottom: 0.125rem;
+}
+.tool-detail-content {
+    font-family: 'JetBrains Mono', 'Fira Code', Consolas, monospace;
+    font-size: 0.7rem;
+    line-height: 1.5;
+    white-space: pre-wrap;
+    word-break: break-all;
+    max-height: 200px;
+    overflow-y: auto;
+    margin: 0;
+    padding: 0.25rem 0;
+    background: transparent;
+    color: inherit;
+}
+.tool-error-text { color: #f87171; }
+
+/* Tool failed state */
+.agent-tool-step.tool-failed .tool-name { color: #f87171; }
+
+/* Config form controls */
+#view-config input[type="text"],
+#view-config input[type="number"],
+#view-config input[type="password"] {
+    height: 40px;
+    transition: border-color 0.2s ease, box-shadow 0.2s ease;
+}
+#view-config input:focus {
+    border-color: #4ABE6E;
+    box-shadow: 0 0 0 3px rgba(74, 190, 110, 0.12);
+}
+#view-config input[type="text"]:hover,
+#view-config input[type="number"]:hover,
+#view-config input[type="password"]:hover {
+    border-color: #94a3b8;
+}
+.dark #view-config input[type="text"]:hover,
+.dark #view-config input[type="number"]:hover,
+.dark #view-config input[type="password"]:hover {
+    border-color: #64748b;
+}
+
+/* Custom dropdown */
+.cfg-dropdown {
+    position: relative;
+    outline: none;
+}
+.cfg-dropdown-selected {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    height: 40px;
+    padding: 0 0.75rem;
+    border-radius: 0.5rem;
+    border: 1px solid #e2e8f0;
+    background: #f8fafc;
+    font-size: 0.875rem;
+    color: #1e293b;
+    cursor: pointer;
+    transition: border-color 0.2s ease, box-shadow 0.2s ease;
+    user-select: none;
+}
+.dark .cfg-dropdown-selected {
+    border-color: #475569;
+    background: rgba(255, 255, 255, 0.05);
+    color: #f1f5f9;
+}
+.cfg-dropdown-selected:hover { border-color: #94a3b8; }
+.dark .cfg-dropdown-selected:hover { border-color: #64748b; }
+.cfg-dropdown.open .cfg-dropdown-selected,
+.cfg-dropdown:focus .cfg-dropdown-selected {
+    border-color: #4ABE6E;
+    box-shadow: 0 0 0 3px rgba(74, 190, 110, 0.12);
+}
+.cfg-dropdown-arrow {
+    font-size: 0.625rem;
+    color: #94a3b8;
+    transition: transform 0.2s ease;
+    flex-shrink: 0;
+    margin-left: 0.5rem;
+}
+.cfg-dropdown.open .cfg-dropdown-arrow { transform: rotate(180deg); }
+.cfg-dropdown-menu {
+    display: none;
+    position: absolute;
+    top: calc(100% + 4px);
+    left: 0;
+    right: 0;
+    z-index: 50;
+    max-height: 240px;
+    overflow-y: auto;
+    border-radius: 0.5rem;
+    border: 1px solid #e2e8f0;
+    background: #ffffff;
+    box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.1), 0 4px 10px -5px rgba(0, 0, 0, 0.04);
+    padding: 4px;
+}
+.dark .cfg-dropdown-menu {
+    border-color: #334155;
+    background: #1e1e1e;
+    box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.4);
+}
+.cfg-dropdown.open .cfg-dropdown-menu { display: block; }
+.cfg-dropdown-item {
+    display: flex;
+    align-items: center;
+    padding: 8px 10px;
+    border-radius: 6px;
+    font-size: 0.875rem;
+    color: #334155;
+    cursor: pointer;
+    transition: background 0.15s ease;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+.dark .cfg-dropdown-item { color: #cbd5e1; }
+.cfg-dropdown-item:hover { background: #f1f5f9; }
+.dark .cfg-dropdown-item:hover { background: rgba(255, 255, 255, 0.08); }
+.cfg-dropdown-item.active {
+    background: rgba(74, 190, 110, 0.1);
+    color: #228547;
+    font-weight: 500;
+}
+.dark .cfg-dropdown-item.active {
+    background: rgba(74, 190, 110, 0.15);
+    color: #74E9A4;
+}
+
+/* API Key masking via CSS (avoids browser password prompts) */
+.cfg-key-masked {
+    -webkit-text-security: disc;
+    text-security: disc;
+}
+
+/* Chat Input */
+#chat-input {
+    resize: none; height: 42px; max-height: 180px;
+    overflow-y: hidden;
+    transition: border-color 0.2s ease;
+}
+
+/* Placeholder Cards */
+.placeholder-card {
+    transition: transform 0.2s ease, box-shadow 0.2s ease;
+}
+.placeholder-card:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 8px 25px -5px rgba(0, 0, 0, 0.1);
+}

common/package_manager.py

@@ -28,7 +28,7 @@ def check_dulwich():
         except ImportError:
             try:
                 install("dulwich")
-            except:
+            except Exception:
                 needwait = True
     try:
         import dulwich

config.py

@@ -160,7 +160,8 @@ available_setting = {
     # chatgpt指令自定义触发词
     "clear_memory_commands": ["#清除记忆"],  # 重置会话指令，必须以#开头
     # channel配置
-    "channel_type": "",  # 通道类型，支持：{wx,wxy,terminal,wechatmp,wechatmp_service,wechatcom_app,dingtalk}
+    "channel_type": "",  # 通道类型，支持多渠道同时运行。单个: "feishu"，多个: "feishu, dingtalk" 或 ["feishu", "dingtalk"]。可选值: web,feishu,dingtalk,wechatmp,wechatmp_service,wechatcom_app
+    "web_console": True,  # 是否自动启动Web控制台（默认启动）。设为False可禁用
     "subscribe_msg": "",  # 订阅消息, 支持: wechatmp, wechatmp_service, wechatcom_app
     "debug": False,  # 是否开启debug模式，开启后会打印更多日志
     "appdata_dir": "",  # 数据目录
@@ -186,6 +187,7 @@ available_setting = {
     "linkai_api_key": "",
     "linkai_app_code": "",
     "linkai_api_base": "https://api.link-ai.tech",  # linkAI服务地址
+    "cloud_host": "client.link-ai.tech",
     "minimax_api_key": "",
     "Minimax_group_id": "",
     "Minimax_base_url": "",
@@ -322,7 +324,7 @@ def load_config():
             logger.info("[INIT] override config by environ args: {}={}".format(name, value))
             try:
                 config[name] = eval(value)
-            except:
+            except Exception:
                 if value == "false":
                     config[name] = False
                 elif value == "true":

lib/itchat/async_components/contact.py

@@ -273,7 +273,7 @@ def get_contact(self, update=False):
             'User-Agent' : config.USER_AGENT, }
         try:
             r = self.s.get(url, headers=headers)
-        except:
+        except Exception:
             logger.info('Failed to fetch contact, that may because of the amount of your chatrooms')
             for chatroom in self.get_chatrooms():
                 self.update_chatroom(chatroom['UserName'], detailedMember=True)

lib/itchat/async_components/hotreload.py

@@ -21,7 +21,7 @@ async def dump_login_status(self, fileDir=None):
         with open(fileDir, 'w') as f:
             f.write('itchat - DELETE THIS')
         os.remove(fileDir)
-    except:
+    except Exception:
         raise Exception('Incorrect fileDir')
     status = {
         'version'   : VERSION,
@@ -57,7 +57,7 @@ async def load_login_status(self, fileDir,
     self.storageClass.loads(j['storage'])
     try:
         msgList, contactList = self.get_msg()
-    except:
+    except Exception:
         msgList = contactList = None
     if (msgList or contactList) is None:
         self.logout()
@@ -97,6 +97,6 @@ async def load_last_login_status(session, cookiesDict):
             'mm_lang': 'zh_CN',
             'MM_WX_NOTIFY_STATE': '1',
             'MM_WX_SOUND_STATE': '1', })
-    except:
+    except Exception:
         logger.info('Load status for push login failed, we may have experienced a cookies change.')
         logger.info('If you are using the newest version of itchat, you may report a bug.')

lib/itchat/async_components/login.py

@@ -330,7 +330,7 @@ async def start_receiving(self, exitCallback=None, getReceivingFnOnly=False):
                 retryCount = 0
             except requests.exceptions.ReadTimeout:
                 pass
-            except:
+            except Exception:
                 retryCount += 1
                 logger.error(traceback.format_exc())
                 if self.receivingRetryCount < retryCount:
@@ -372,7 +372,7 @@ def sync_check(self):
             # 6f:00:8a:9c:09:74:e4:d8:e0:14:bf:96:3a:56:a0:64:1b:a4:25:5d:12:f4:31:a5:30:f1:c6:48:5f:c3:75:6a:99:93
             # seems like status of typing, but before I make further achievement code will remain like this
             return '2'
-        except:
+        except Exception:
             raise
     r.raise_for_status()
     regx = r'window.synccheck={retcode:"(\d+)",selector:"(\d+)"}'

lib/itchat/async_components/register.py

@@ -63,7 +63,7 @@ async def configured_reply(self, event_stream, payload, message_container):
                 r = await replyFn(msg)
                 if r is not None:
                     await self.send(r, msg.get('FromUserName'))
-            except:
+            except Exception:
                 logger.warning(traceback.format_exc())
 
 def msg_register(self, msgType, isFriendChat=False, isGroupChat=False, isMpChat=False):

lib/itchat/components/contact.py

@@ -287,7 +287,7 @@ def get_contact(self, update=False):
             'User-Agent': config.USER_AGENT, }
         try:
             r = self.s.get(url, headers=headers)
-        except:
+        except Exception:
             logger.info(
                 'Failed to fetch contact, that may because of the amount of your chatrooms')
             for chatroom in self.get_chatrooms():

lib/itchat/components/hotreload.py

@@ -21,7 +21,7 @@ def dump_login_status(self, fileDir=None):
         with open(fileDir, 'w') as f:
             f.write('itchat - DELETE THIS')
         os.remove(fileDir)
-    except:
+    except Exception:
         raise Exception('Incorrect fileDir')
     status = {
         'version'   : VERSION,
@@ -57,7 +57,7 @@ def load_login_status(self, fileDir,
     self.storageClass.loads(j['storage'])
     try:
         msgList, contactList = self.get_msg()
-    except:
+    except Exception:
         msgList = contactList = None
     if (msgList or contactList) is None:
         self.logout()
@@ -97,6 +97,6 @@ def load_last_login_status(session, cookiesDict):
             'mm_lang': 'zh_CN',
             'MM_WX_NOTIFY_STATE': '1',
             'MM_WX_SOUND_STATE': '1', })
-    except:
+    except Exception:
         logger.info('Load status for push login failed, we may have experienced a cookies change.')
         logger.info('If you are using the newest version of itchat, you may report a bug.')

lib/itchat/components/login.py

@@ -318,7 +318,7 @@ def start_receiving(self, exitCallback=None, getReceivingFnOnly=False):
                 retryCount = 0
             except requests.exceptions.ReadTimeout:
                 pass
-            except:
+            except Exception:
                 retryCount += 1
                 logger.error(traceback.format_exc())
                 if self.receivingRetryCount < retryCount:
@@ -364,7 +364,7 @@ def sync_check(self):
             # 6f:00:8a:9c:09:74:e4:d8:e0:14:bf:96:3a:56:a0:64:1b:a4:25:5d:12:f4:31:a5:30:f1:c6:48:5f:c3:75:6a:99:93
             # seems like status of typing, but before I make further achievement code will remain like this
             return '2'
-        except:
+        except Exception:
             raise
     r.raise_for_status()
     regx = r'window.synccheck={retcode:"(\d+)",selector:"(\d+)"}'

lib/itchat/components/register.py

@@ -63,7 +63,7 @@ def configured_reply(self):
                 r = replyFn(msg)
                 if r is not None:
                     self.send(r, msg.get('FromUserName'))
-            except:
+            except Exception:
                 logger.warning(traceback.format_exc())
 
 def msg_register(self, msgType, isFriendChat=False, isGroupChat=False, isMpChat=False):

lib/itchat/utils.py

@@ -82,7 +82,7 @@ def check_file(fileDir):
         with open(fileDir):
             pass
         return True
-    except:
+    except Exception:
         return False
 
 def print_qr(fileDir):
@@ -133,7 +133,7 @@ def test_connect(retryTime=5):
         try:
             r = requests.get(config.BASE_URL)
             return True
-        except:
+        except Exception:
             if i == retryTime - 1:
                 logger.error(traceback.format_exc())
                 return False

models/chatgpt/chat_gpt_bot.py

@@ -208,7 +208,7 @@ class ChatGPTBot(Bot, OpenAIImage, OpenAICompatibleBot):
             try:
                 os.remove(image_path)
                 logger.debug(f"[CHATGPT] Removed temp image file: {image_path}")
-            except:
+            except Exception:
                 pass
             
             return Reply(ReplyType.TEXT, content)

models/claudeapi/claude_api_bot.py

@@ -383,7 +383,7 @@ class ClaudeAPIBot(Bot, OpenAIImage):
                 try:
                     error_data = json.loads(error_text)
                     error_msg = error_data.get("error", {}).get("message", error_text)
-                except:
+                except Exception:
                     error_msg = error_text or "Unknown error"
 
                 yield {

models/gemini/google_gemini_bot.py

@@ -347,7 +347,7 @@ class GoogleGeminiBot(Bot):
                                     tool_result_data = json.loads(tool_content)
                                 else:
                                     tool_result_data = tool_content
-                            except:
+                            except Exception:
                                 tool_result_data = {"result": tool_content}
                             
                             # Find the tool name from previous messages

models/linkai/link_ai_bot.py

@@ -107,7 +107,7 @@ class LinkAIBot(Bot, OpenAICompatibleBot):
                 "presence_penalty": conf().get("presence_penalty", 0.0),  # [-2,2]之间，该值越大则更倾向于产生不同的内容
                 "session_id": session_id,
                 "sender_id": session_id,
-                "channel_type": conf().get("channel_type", "wx")
+                "channel_type": context.get("channel_type") or conf().get("channel_type", "web")
             }
             try:
                 from linkai import LinkAIClient
@@ -526,6 +526,14 @@ def _linkai_call_with_tools(self, messages, tools=None, stream=False, **kwargs):
         logger.debug(f"[LinkAI] messages: {len(messages)}, tools: {len(tools) if tools else 0}, stream: {stream}")
         
         # Build request parameters (LinkAI uses OpenAI-compatible format)
+        raw_ct = conf().get("channel_type", "web")
+        if isinstance(raw_ct, list):
+            channel_type = raw_ct[0] if raw_ct else "web"
+        elif isinstance(raw_ct, str) and "," in raw_ct:
+            channel_type = raw_ct.split(",")[0].strip()
+        else:
+            channel_type = raw_ct
+
         body = {
             "messages": messages,
             "model": kwargs.get("model", conf().get("model") or "gpt-3.5-turbo"),
@@ -533,7 +541,8 @@ def _linkai_call_with_tools(self, messages, tools=None, stream=False, **kwargs):
             "top_p": kwargs.get("top_p", conf().get("top_p", 1)),
             "frequency_penalty": kwargs.get("frequency_penalty", conf().get("frequency_penalty", 0.0)),
             "presence_penalty": kwargs.get("presence_penalty", conf().get("presence_penalty", 0.0)),
-            "stream": stream
+            "stream": stream,
+            "channel_type": kwargs.get("channel_type", channel_type),
         }
 
         if tools:
@@ -608,7 +617,7 @@ def _handle_linkai_stream_response(self, base_url, headers, body):
             try:
                 error_data = json.loads(error_text)
                 error_msg = error_data.get("error", {}).get("message", error_text)
-            except:
+            except Exception:
                 error_msg = error_text or "Unknown error"
             
             yield {

plugins/godcmd/godcmd.py

@@ -140,7 +140,9 @@ def get_help_text(isadmin, isgroup):
     for cmd, info in COMMANDS.items():
         if cmd in ["auth", "set_openai_api_key", "reset_openai_api_key", "set_gpt_model", "reset_gpt_model", "gpt_model"]:  # 不显示帮助指令
             continue
-        if cmd == "id" and conf().get("channel_type", "wx") not in ["wxy", "wechatmp"]:
+        raw_ct = conf().get("channel_type", "web")
+        active_channels = raw_ct if isinstance(raw_ct, list) else [c.strip() for c in str(raw_ct).split(",")]
+        if cmd == "id" and not any(c in ["wxy", "wechatmp"] for c in active_channels):
             continue
         alias = ["#" + a for a in info["alias"][:1]]
         help_text += f"{','.join(alias)} "