merge: sync upstream/main into feat/multi-agent-routing

Resolve conflicts: - pkg/agent/loop.go: integrate context compression, command handling, utf8 token estimation, and summarization notification into multi-agent routing architecture - pkg/config/config_test.go: merge imports from both branches - pkg/agent/loop_test.go: update test to use registry-based sessions
2026-06-12 18:08:54 +00:00 · 2026-02-16 10:34:55 -03:00
parent 5e89264536 13e4028d42
commit 12007b5670
69 changed files with 4550 additions and 559 deletions
@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"strings"
 	"time"

 	"github.com/bwmarrin/discordgo"
@@ -100,15 +101,156 @@ func (c *DiscordChannel) Send(ctx context.Context, msg bus.OutboundMessage) erro
 		return fmt.Errorf("channel ID is empty")
 	}

-	message := msg.Content
+	runes := []rune(msg.Content)
+	if len(runes) == 0 {
+		return nil
+	}

+	chunks := splitMessage(msg.Content, 1500) // Discord has a limit of 2000 characters per message, leave 500 for natural split e.g. code blocks
+
+	for _, chunk := range chunks {
+		if err := c.sendChunk(ctx, channelID, chunk); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// splitMessage splits long messages into chunks, preserving code block integrity
+// Uses natural boundaries (newlines, spaces) and extends messages slightly to avoid breaking code blocks
+func splitMessage(content string, limit int) []string {
+	var messages []string
+
+	for len(content) > 0 {
+		if len(content) <= limit {
+			messages = append(messages, content)
+			break
+		}
+
+		msgEnd := limit
+
+		// Find natural split point within the limit
+		msgEnd = findLastNewline(content[:limit], 200)
+		if msgEnd <= 0 {
+			msgEnd = findLastSpace(content[:limit], 100)
+		}
+		if msgEnd <= 0 {
+			msgEnd = limit
+		}
+
+		// Check if this would end with an incomplete code block
+		candidate := content[:msgEnd]
+		unclosedIdx := findLastUnclosedCodeBlock(candidate)
+
+		if unclosedIdx >= 0 {
+			// Message would end with incomplete code block
+			// Try to extend to include the closing ``` (with some buffer)
+			extendedLimit := limit + 500 // Allow 500 char buffer for code blocks
+			if len(content) > extendedLimit {
+				closingIdx := findNextClosingCodeBlock(content, msgEnd)
+				if closingIdx > 0 && closingIdx <= extendedLimit {
+					// Extend to include the closing ```
+					msgEnd = closingIdx
+				} else {
+					// Can't find closing, split before the code block
+					msgEnd = findLastNewline(content[:unclosedIdx], 200)
+					if msgEnd <= 0 {
+						msgEnd = findLastSpace(content[:unclosedIdx], 100)
+					}
+					if msgEnd <= 0 {
+						msgEnd = unclosedIdx
+					}
+				}
+			} else {
+				// Remaining content fits within extended limit
+				msgEnd = len(content)
+			}
+		}
+
+		if msgEnd <= 0 {
+			msgEnd = limit
+		}
+
+		messages = append(messages, content[:msgEnd])
+		content = strings.TrimSpace(content[msgEnd:])
+	}
+
+	return messages
+}
+
+// findLastUnclosedCodeBlock finds the last opening ``` that doesn't have a closing ```
+// Returns the position of the opening ``` or -1 if all code blocks are complete
+func findLastUnclosedCodeBlock(text string) int {
+	count := 0
+	lastOpenIdx := -1
+
+	for i := 0; i < len(text); i++ {
+		if i+2 < len(text) && text[i] == '`' && text[i+1] == '`' && text[i+2] == '`' {
+			if count == 0 {
+				lastOpenIdx = i
+			}
+			count++
+			i += 2
+		}
+	}
+
+	// If odd number of ``` markers, last one is unclosed
+	if count%2 == 1 {
+		return lastOpenIdx
+	}
+	return -1
+}
+
+// findNextClosingCodeBlock finds the next closing ``` starting from a position
+// Returns the position after the closing ``` or -1 if not found
+func findNextClosingCodeBlock(text string, startIdx int) int {
+	for i := startIdx; i < len(text); i++ {
+		if i+2 < len(text) && text[i] == '`' && text[i+1] == '`' && text[i+2] == '`' {
+			return i + 3
+		}
+	}
+	return -1
+}
+
+// findLastNewline finds the last newline character within the last N characters
+// Returns the position of the newline or -1 if not found
+func findLastNewline(s string, searchWindow int) int {
+	searchStart := len(s) - searchWindow
+	if searchStart < 0 {
+		searchStart = 0
+	}
+	for i := len(s) - 1; i >= searchStart; i-- {
+		if s[i] == '\n' {
+			return i
+		}
+	}
+	return -1
+}
+
+// findLastSpace finds the last space character within the last N characters
+// Returns the position of the space or -1 if not found
+func findLastSpace(s string, searchWindow int) int {
+	searchStart := len(s) - searchWindow
+	if searchStart < 0 {
+		searchStart = 0
+	}
+	for i := len(s) - 1; i >= searchStart; i-- {
+		if s[i] == ' ' || s[i] == '\t' {
+			return i
+		}
+	}
+	return -1
+}
+
+func (c *DiscordChannel) sendChunk(ctx context.Context, channelID, content string) error {
 	// 使用传入的 ctx 进行超时控制
 	sendCtx, cancel := context.WithTimeout(ctx, sendTimeout)
 	defer cancel()

 	done := make(chan error, 1)
 	go func() {
-		_, err := c.session.ChannelMessageSend(channelID, message)
+		_, err := c.session.ChannelMessageSend(channelID, content)
 		done <- err
 	}()

@@ -140,6 +282,12 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
 		return
 	}

+	if err := c.session.ChannelTyping(m.ChannelID); err != nil {
+		logger.ErrorCF("discord", "Failed to send typing indicator", map[string]any{
+			"error": err.Error(),
+		})
+	}
+
 	// 检查白名单，避免为被拒绝的用户下载附件和转录
 	if !c.IsAllowed(m.Author.ID) {
 		logger.DebugCF("discord", "Message rejected by allowlist", map[string]any{
@@ -48,7 +48,7 @@ func (m *Manager) initChannels() error {

 	if m.config.Channels.Telegram.Enabled && m.config.Channels.Telegram.Token != "" {
 		logger.DebugC("channels", "Attempting to initialize Telegram channel")
-		telegram, err := NewTelegramChannel(m.config.Channels.Telegram, m.bus)
+		telegram, err := NewTelegramChannel(m.config, m.bus)
 		if err != nil {
 			logger.ErrorCF("channels", "Failed to initialize Telegram channel", map[string]interface{}{
 				"error": err.Error(),
@@ -163,6 +163,19 @@ func (m *Manager) initChannels() error {
 		}
 	}

+	if m.config.Channels.OneBot.Enabled && m.config.Channels.OneBot.WSUrl != "" {
+		logger.DebugC("channels", "Attempting to initialize OneBot channel")
+		onebot, err := NewOneBotChannel(m.config.Channels.OneBot, m.bus)
+		if err != nil {
+			logger.ErrorCF("channels", "Failed to initialize OneBot channel", map[string]interface{}{
+				"error": err.Error(),
+			})
+		} else {
+			m.channels["onebot"] = onebot
+			logger.InfoC("channels", "OneBot channel enabled successfully")
+		}
+	}
+
 	logger.InfoCF("channels", "Channel initialization completed", map[string]interface{}{
 		"enabled_channels": len(m.channels),
 	})
@@ -0,0 +1,686 @@
+package channels
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/logger"
+)
+
+type OneBotChannel struct {
+	*BaseChannel
+	config      config.OneBotConfig
+	conn        *websocket.Conn
+	ctx         context.Context
+	cancel      context.CancelFunc
+	dedup       map[string]struct{}
+	dedupRing   []string
+	dedupIdx    int
+	mu          sync.Mutex
+	writeMu     sync.Mutex
+	echoCounter int64
+}
+
+type oneBotRawEvent struct {
+	PostType      string          `json:"post_type"`
+	MessageType   string          `json:"message_type"`
+	SubType       string          `json:"sub_type"`
+	MessageID     json.RawMessage `json:"message_id"`
+	UserID        json.RawMessage `json:"user_id"`
+	GroupID       json.RawMessage `json:"group_id"`
+	RawMessage    string          `json:"raw_message"`
+	Message       json.RawMessage `json:"message"`
+	Sender        json.RawMessage `json:"sender"`
+	SelfID        json.RawMessage `json:"self_id"`
+	Time          json.RawMessage `json:"time"`
+	MetaEventType string          `json:"meta_event_type"`
+	Echo          string          `json:"echo"`
+	RetCode       json.RawMessage `json:"retcode"`
+	Status        BotStatus       `json:"status"`
+}
+
+type BotStatus struct {
+	Online bool `json:"online"`
+	Good   bool `json:"good"`
+}
+
+type oneBotSender struct {
+	UserID   json.RawMessage `json:"user_id"`
+	Nickname string          `json:"nickname"`
+	Card     string          `json:"card"`
+}
+
+type oneBotEvent struct {
+	PostType       string
+	MessageType    string
+	SubType        string
+	MessageID      string
+	UserID         int64
+	GroupID        int64
+	Content        string
+	RawContent     string
+	IsBotMentioned bool
+	Sender         oneBotSender
+	SelfID         int64
+	Time           int64
+	MetaEventType  string
+}
+
+type oneBotAPIRequest struct {
+	Action string      `json:"action"`
+	Params interface{} `json:"params"`
+	Echo   string      `json:"echo,omitempty"`
+}
+
+type oneBotSendPrivateMsgParams struct {
+	UserID  int64  `json:"user_id"`
+	Message string `json:"message"`
+}
+
+type oneBotSendGroupMsgParams struct {
+	GroupID int64  `json:"group_id"`
+	Message string `json:"message"`
+}
+
+func NewOneBotChannel(cfg config.OneBotConfig, messageBus *bus.MessageBus) (*OneBotChannel, error) {
+	base := NewBaseChannel("onebot", cfg, messageBus, cfg.AllowFrom)
+
+	const dedupSize = 1024
+	return &OneBotChannel{
+		BaseChannel: base,
+		config:      cfg,
+		dedup:       make(map[string]struct{}, dedupSize),
+		dedupRing:   make([]string, dedupSize),
+		dedupIdx:    0,
+	}, nil
+}
+
+func (c *OneBotChannel) Start(ctx context.Context) error {
+	if c.config.WSUrl == "" {
+		return fmt.Errorf("OneBot ws_url not configured")
+	}
+
+	logger.InfoCF("onebot", "Starting OneBot channel", map[string]interface{}{
+		"ws_url": c.config.WSUrl,
+	})
+
+	c.ctx, c.cancel = context.WithCancel(ctx)
+
+	if err := c.connect(); err != nil {
+		logger.WarnCF("onebot", "Initial connection failed, will retry in background", map[string]interface{}{
+			"error": err.Error(),
+		})
+	} else {
+		go c.listen()
+	}
+
+	if c.config.ReconnectInterval > 0 {
+		go c.reconnectLoop()
+	} else {
+		// If reconnect is disabled but initial connection failed, we cannot recover
+		if c.conn == nil {
+			return fmt.Errorf("failed to connect to OneBot and reconnect is disabled")
+		}
+	}
+
+	c.setRunning(true)
+	logger.InfoC("onebot", "OneBot channel started successfully")
+
+	return nil
+}
+
+func (c *OneBotChannel) connect() error {
+	dialer := websocket.DefaultDialer
+	dialer.HandshakeTimeout = 10 * time.Second
+
+	header := make(map[string][]string)
+	if c.config.AccessToken != "" {
+		header["Authorization"] = []string{"Bearer " + c.config.AccessToken}
+	}
+
+	conn, _, err := dialer.Dial(c.config.WSUrl, header)
+	if err != nil {
+		return err
+	}
+
+	c.mu.Lock()
+	c.conn = conn
+	c.mu.Unlock()
+
+	logger.InfoC("onebot", "WebSocket connected")
+	return nil
+}
+
+func (c *OneBotChannel) reconnectLoop() {
+	interval := time.Duration(c.config.ReconnectInterval) * time.Second
+	if interval < 5*time.Second {
+		interval = 5 * time.Second
+	}
+
+	for {
+		select {
+		case <-c.ctx.Done():
+			return
+		case <-time.After(interval):
+			c.mu.Lock()
+			conn := c.conn
+			c.mu.Unlock()
+
+			if conn == nil {
+				logger.InfoC("onebot", "Attempting to reconnect...")
+				if err := c.connect(); err != nil {
+					logger.ErrorCF("onebot", "Reconnect failed", map[string]interface{}{
+						"error": err.Error(),
+					})
+				} else {
+					go c.listen()
+				}
+			}
+		}
+	}
+}
+
+func (c *OneBotChannel) Stop(ctx context.Context) error {
+	logger.InfoC("onebot", "Stopping OneBot channel")
+	c.setRunning(false)
+
+	if c.cancel != nil {
+		c.cancel()
+	}
+
+	c.mu.Lock()
+	if c.conn != nil {
+		c.conn.Close()
+		c.conn = nil
+	}
+	c.mu.Unlock()
+
+	return nil
+}
+
+func (c *OneBotChannel) Send(ctx context.Context, msg bus.OutboundMessage) error {
+	if !c.IsRunning() {
+		return fmt.Errorf("OneBot channel not running")
+	}
+
+	c.mu.Lock()
+	conn := c.conn
+	c.mu.Unlock()
+
+	if conn == nil {
+		return fmt.Errorf("OneBot WebSocket not connected")
+	}
+
+	action, params, err := c.buildSendRequest(msg)
+	if err != nil {
+		return err
+	}
+
+	c.writeMu.Lock()
+	c.echoCounter++
+	echo := fmt.Sprintf("send_%d", c.echoCounter)
+	c.writeMu.Unlock()
+
+	req := oneBotAPIRequest{
+		Action: action,
+		Params: params,
+		Echo:   echo,
+	}
+
+	data, err := json.Marshal(req)
+	if err != nil {
+		return fmt.Errorf("failed to marshal OneBot request: %w", err)
+	}
+
+	c.writeMu.Lock()
+	err = conn.WriteMessage(websocket.TextMessage, data)
+	c.writeMu.Unlock()
+
+	if err != nil {
+		logger.ErrorCF("onebot", "Failed to send message", map[string]interface{}{
+			"error": err.Error(),
+		})
+		return err
+	}
+
+	return nil
+}
+
+func (c *OneBotChannel) buildSendRequest(msg bus.OutboundMessage) (string, interface{}, error) {
+	chatID := msg.ChatID
+
+	if len(chatID) > 6 && chatID[:6] == "group:" {
+		groupID, err := strconv.ParseInt(chatID[6:], 10, 64)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid group ID in chatID: %s", chatID)
+		}
+		return "send_group_msg", oneBotSendGroupMsgParams{
+			GroupID: groupID,
+			Message: msg.Content,
+		}, nil
+	}
+
+	if len(chatID) > 8 && chatID[:8] == "private:" {
+		userID, err := strconv.ParseInt(chatID[8:], 10, 64)
+		if err != nil {
+			return "", nil, fmt.Errorf("invalid user ID in chatID: %s", chatID)
+		}
+		return "send_private_msg", oneBotSendPrivateMsgParams{
+			UserID:  userID,
+			Message: msg.Content,
+		}, nil
+	}
+
+	userID, err := strconv.ParseInt(chatID, 10, 64)
+	if err != nil {
+		return "", nil, fmt.Errorf("invalid chatID for OneBot: %s", chatID)
+	}
+
+	return "send_private_msg", oneBotSendPrivateMsgParams{
+		UserID:  userID,
+		Message: msg.Content,
+	}, nil
+}
+
+func (c *OneBotChannel) listen() {
+	for {
+		select {
+		case <-c.ctx.Done():
+			return
+		default:
+			c.mu.Lock()
+			conn := c.conn
+			c.mu.Unlock()
+
+			if conn == nil {
+				logger.WarnC("onebot", "WebSocket connection is nil, listener exiting")
+				return
+			}
+
+			_, message, err := conn.ReadMessage()
+			if err != nil {
+				logger.ErrorCF("onebot", "WebSocket read error", map[string]interface{}{
+					"error": err.Error(),
+				})
+				c.mu.Lock()
+				if c.conn != nil {
+					c.conn.Close()
+					c.conn = nil
+				}
+				c.mu.Unlock()
+				return
+			}
+
+			logger.DebugCF("onebot", "Raw WebSocket message received", map[string]interface{}{
+				"length":  len(message),
+				"payload": string(message),
+			})
+
+			var raw oneBotRawEvent
+			if err := json.Unmarshal(message, &raw); err != nil {
+				logger.WarnCF("onebot", "Failed to unmarshal raw event", map[string]interface{}{
+					"error":   err.Error(),
+					"payload": string(message),
+				})
+				continue
+			}
+
+			if raw.Echo != "" || raw.Status.Online || raw.Status.Good {
+				logger.DebugCF("onebot", "Received API response, skipping", map[string]interface{}{
+					"echo":   raw.Echo,
+					"status": raw.Status,
+				})
+				continue
+			}
+
+			logger.DebugCF("onebot", "Parsed raw event", map[string]interface{}{
+				"post_type":       raw.PostType,
+				"message_type":    raw.MessageType,
+				"sub_type":        raw.SubType,
+				"meta_event_type": raw.MetaEventType,
+			})
+
+			c.handleRawEvent(&raw)
+		}
+	}
+}
+
+func parseJSONInt64(raw json.RawMessage) (int64, error) {
+	if len(raw) == 0 {
+		return 0, nil
+	}
+
+	var n int64
+	if err := json.Unmarshal(raw, &n); err == nil {
+		return n, nil
+	}
+
+	var s string
+	if err := json.Unmarshal(raw, &s); err == nil {
+		return strconv.ParseInt(s, 10, 64)
+	}
+	return 0, fmt.Errorf("cannot parse as int64: %s", string(raw))
+}
+
+func parseJSONString(raw json.RawMessage) string {
+	if len(raw) == 0 {
+		return ""
+	}
+	var s string
+	if err := json.Unmarshal(raw, &s); err == nil {
+		return s
+	}
+
+	return string(raw)
+}
+
+type parseMessageResult struct {
+	Text           string
+	IsBotMentioned bool
+}
+
+func parseMessageContentEx(raw json.RawMessage, selfID int64) parseMessageResult {
+	if len(raw) == 0 {
+		return parseMessageResult{}
+	}
+
+	var s string
+	if err := json.Unmarshal(raw, &s); err == nil {
+		mentioned := false
+		if selfID > 0 {
+			cqAt := fmt.Sprintf("[CQ:at,qq=%d]", selfID)
+			if strings.Contains(s, cqAt) {
+				mentioned = true
+				s = strings.ReplaceAll(s, cqAt, "")
+				s = strings.TrimSpace(s)
+			}
+		}
+		return parseMessageResult{Text: s, IsBotMentioned: mentioned}
+	}
+
+	var segments []map[string]interface{}
+	if err := json.Unmarshal(raw, &segments); err == nil {
+		var text string
+		mentioned := false
+		selfIDStr := strconv.FormatInt(selfID, 10)
+		for _, seg := range segments {
+			segType, _ := seg["type"].(string)
+			data, _ := seg["data"].(map[string]interface{})
+			switch segType {
+			case "text":
+				if data != nil {
+					if t, ok := data["text"].(string); ok {
+						text += t
+					}
+				}
+			case "at":
+				if data != nil && selfID > 0 {
+					qqVal := fmt.Sprintf("%v", data["qq"])
+					if qqVal == selfIDStr || qqVal == "all" {
+						mentioned = true
+					}
+				}
+			}
+		}
+		return parseMessageResult{Text: strings.TrimSpace(text), IsBotMentioned: mentioned}
+	}
+	return parseMessageResult{}
+}
+
+func (c *OneBotChannel) handleRawEvent(raw *oneBotRawEvent) {
+	switch raw.PostType {
+	case "message":
+		evt, err := c.normalizeMessageEvent(raw)
+		if err != nil {
+			logger.WarnCF("onebot", "Failed to normalize message event", map[string]interface{}{
+				"error": err.Error(),
+			})
+			return
+		}
+		c.handleMessage(evt)
+	case "meta_event":
+		c.handleMetaEvent(raw)
+	case "notice":
+		logger.DebugCF("onebot", "Notice event received", map[string]interface{}{
+			"sub_type": raw.SubType,
+		})
+	case "request":
+		logger.DebugCF("onebot", "Request event received", map[string]interface{}{
+			"sub_type": raw.SubType,
+		})
+	case "":
+		logger.DebugCF("onebot", "Event with empty post_type (possibly API response)", map[string]interface{}{
+			"echo":   raw.Echo,
+			"status": raw.Status,
+		})
+	default:
+		logger.DebugCF("onebot", "Unknown post_type", map[string]interface{}{
+			"post_type": raw.PostType,
+		})
+	}
+}
+
+func (c *OneBotChannel) normalizeMessageEvent(raw *oneBotRawEvent) (*oneBotEvent, error) {
+	userID, err := parseJSONInt64(raw.UserID)
+	if err != nil {
+		return nil, fmt.Errorf("parse user_id: %w (raw: %s)", err, string(raw.UserID))
+	}
+
+	groupID, _ := parseJSONInt64(raw.GroupID)
+	selfID, _ := parseJSONInt64(raw.SelfID)
+	ts, _ := parseJSONInt64(raw.Time)
+	messageID := parseJSONString(raw.MessageID)
+
+	parsed := parseMessageContentEx(raw.Message, selfID)
+	isBotMentioned := parsed.IsBotMentioned
+
+	content := raw.RawMessage
+	if content == "" {
+		content = parsed.Text
+	} else if selfID > 0 {
+		cqAt := fmt.Sprintf("[CQ:at,qq=%d]", selfID)
+		if strings.Contains(content, cqAt) {
+			isBotMentioned = true
+			content = strings.ReplaceAll(content, cqAt, "")
+			content = strings.TrimSpace(content)
+		}
+	}
+
+	var sender oneBotSender
+	if len(raw.Sender) > 0 {
+		if err := json.Unmarshal(raw.Sender, &sender); err != nil {
+			logger.WarnCF("onebot", "Failed to parse sender", map[string]interface{}{
+				"error":  err.Error(),
+				"sender": string(raw.Sender),
+			})
+		}
+	}
+
+	logger.DebugCF("onebot", "Normalized message event", map[string]interface{}{
+		"message_type": raw.MessageType,
+		"user_id":      userID,
+		"group_id":     groupID,
+		"message_id":   messageID,
+		"content_len":  len(content),
+		"nickname":     sender.Nickname,
+	})
+
+	return &oneBotEvent{
+		PostType:       raw.PostType,
+		MessageType:    raw.MessageType,
+		SubType:        raw.SubType,
+		MessageID:      messageID,
+		UserID:         userID,
+		GroupID:        groupID,
+		Content:        content,
+		RawContent:     raw.RawMessage,
+		IsBotMentioned: isBotMentioned,
+		Sender:         sender,
+		SelfID:         selfID,
+		Time:           ts,
+		MetaEventType:  raw.MetaEventType,
+	}, nil
+}
+
+func (c *OneBotChannel) handleMetaEvent(raw *oneBotRawEvent) {
+	switch raw.MetaEventType {
+	case "lifecycle":
+		logger.InfoCF("onebot", "Lifecycle event", map[string]interface{}{
+			"sub_type": raw.SubType,
+		})
+	case "heartbeat":
+		logger.DebugC("onebot", "Heartbeat received")
+	default:
+		logger.DebugCF("onebot", "Unknown meta_event_type", map[string]interface{}{
+			"meta_event_type": raw.MetaEventType,
+		})
+	}
+}
+
+func (c *OneBotChannel) handleMessage(evt *oneBotEvent) {
+	if c.isDuplicate(evt.MessageID) {
+		logger.DebugCF("onebot", "Duplicate message, skipping", map[string]interface{}{
+			"message_id": evt.MessageID,
+		})
+		return
+	}
+
+	content := evt.Content
+	if content == "" {
+		logger.DebugCF("onebot", "Received empty message, ignoring", map[string]interface{}{
+			"message_id": evt.MessageID,
+		})
+		return
+	}
+
+	senderID := strconv.FormatInt(evt.UserID, 10)
+	var chatID string
+
+	metadata := map[string]string{
+		"message_id": evt.MessageID,
+	}
+
+	switch evt.MessageType {
+	case "private":
+		chatID = "private:" + senderID
+		logger.InfoCF("onebot", "Received private message", map[string]interface{}{
+			"sender":     senderID,
+			"message_id": evt.MessageID,
+			"length":     len(content),
+			"content":    truncate(content, 100),
+		})
+
+	case "group":
+		groupIDStr := strconv.FormatInt(evt.GroupID, 10)
+		chatID = "group:" + groupIDStr
+		metadata["group_id"] = groupIDStr
+
+		senderUserID, _ := parseJSONInt64(evt.Sender.UserID)
+		if senderUserID > 0 {
+			metadata["sender_user_id"] = strconv.FormatInt(senderUserID, 10)
+		}
+
+		if evt.Sender.Card != "" {
+			metadata["sender_name"] = evt.Sender.Card
+		} else if evt.Sender.Nickname != "" {
+			metadata["sender_name"] = evt.Sender.Nickname
+		}
+
+		triggered, strippedContent := c.checkGroupTrigger(content, evt.IsBotMentioned)
+		if !triggered {
+			logger.DebugCF("onebot", "Group message ignored (no trigger)", map[string]interface{}{
+				"sender":       senderID,
+				"group":        groupIDStr,
+				"is_mentioned": evt.IsBotMentioned,
+				"content":      truncate(content, 100),
+			})
+			return
+		}
+		content = strippedContent
+
+		logger.InfoCF("onebot", "Received group message", map[string]interface{}{
+			"sender":       senderID,
+			"group":        groupIDStr,
+			"message_id":   evt.MessageID,
+			"is_mentioned": evt.IsBotMentioned,
+			"length":       len(content),
+			"content":      truncate(content, 100),
+		})
+
+	default:
+		logger.WarnCF("onebot", "Unknown message type, cannot route", map[string]interface{}{
+			"type":       evt.MessageType,
+			"message_id": evt.MessageID,
+			"user_id":    evt.UserID,
+		})
+		return
+	}
+
+	if evt.Sender.Nickname != "" {
+		metadata["nickname"] = evt.Sender.Nickname
+	}
+
+	logger.DebugCF("onebot", "Forwarding message to bus", map[string]interface{}{
+		"sender_id": senderID,
+		"chat_id":   chatID,
+		"content":   truncate(content, 100),
+	})
+
+	c.HandleMessage(senderID, chatID, content, []string{}, metadata)
+}
+
+func (c *OneBotChannel) isDuplicate(messageID string) bool {
+	if messageID == "" || messageID == "0" {
+		return false
+	}
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if _, exists := c.dedup[messageID]; exists {
+		return true
+	}
+
+	if old := c.dedupRing[c.dedupIdx]; old != "" {
+		delete(c.dedup, old)
+	}
+	c.dedupRing[c.dedupIdx] = messageID
+	c.dedup[messageID] = struct{}{}
+	c.dedupIdx = (c.dedupIdx + 1) % len(c.dedupRing)
+
+	return false
+}
+
+func truncate(s string, n int) string {
+	runes := []rune(s)
+	if len(runes) <= n {
+		return s
+	}
+	return string(runes[:n]) + "..."
+}
+
+func (c *OneBotChannel) checkGroupTrigger(content string, isBotMentioned bool) (triggered bool, strippedContent string) {
+	if isBotMentioned {
+		return true, strings.TrimSpace(content)
+	}
+
+	for _, prefix := range c.config.GroupTriggerPrefix {
+		if prefix == "" {
+			continue
+		}
+		if strings.HasPrefix(content, prefix) {
+			return true, strings.TrimSpace(strings.TrimPrefix(content, prefix))
+		}
+	}
+
+	return false, content
+}
@@ -308,6 +308,13 @@ func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) {
 		return
 	}

+	if !c.IsAllowed(ev.User) {
+		logger.DebugCF("slack", "Mention rejected by allowlist", map[string]interface{}{
+			"user_id": ev.User,
+		})
+		return
+	}
+
 	senderID := ev.User
 	channelID := ev.Channel
 	threadTS := ev.ThreadTimeStamp
@@ -367,6 +374,13 @@ func (c *SlackChannel) handleSlashCommand(event socketmode.Event) {
 		c.socketClient.Ack(*event.Request)
 	}

+	if !c.IsAllowed(cmd.UserID) {
+		logger.DebugCF("slack", "Slash command rejected by allowlist", map[string]interface{}{
+			"user_id": cmd.UserID,
+		})
+		return
+	}
+
 	senderID := cmd.UserID
 	channelID := cmd.ChannelID
 	chatID := channelID
@@ -11,7 +11,10 @@ import (
 	"sync"
 	"time"

+	th "github.com/mymmrac/telego/telegohandler"
+
 	"github.com/mymmrac/telego"
+	"github.com/mymmrac/telego/telegohandler"
 	tu "github.com/mymmrac/telego/telegoutil"

 	"github.com/sipeed/picoclaw/pkg/bus"
@@ -24,7 +27,8 @@ import (
 type TelegramChannel struct {
 	*BaseChannel
 	bot          *telego.Bot
-	config       config.TelegramConfig
+	commands     TelegramCommander
+	config       *config.Config
 	chatIDs      map[string]int64
 	transcriber  *voice.GroqTranscriber
 	placeholders sync.Map // chatID -> messageID
@@ -41,13 +45,14 @@ func (c *thinkingCancel) Cancel() {
 	}
 }

-func NewTelegramChannel(cfg config.TelegramConfig, bus *bus.MessageBus) (*TelegramChannel, error) {
+func NewTelegramChannel(cfg *config.Config, bus *bus.MessageBus) (*TelegramChannel, error) {
 	var opts []telego.BotOption
+	telegramCfg := cfg.Channels.Telegram

-	if cfg.Proxy != "" {
-		proxyURL, parseErr := url.Parse(cfg.Proxy)
+	if telegramCfg.Proxy != "" {
+		proxyURL, parseErr := url.Parse(telegramCfg.Proxy)
 		if parseErr != nil {
-			return nil, fmt.Errorf("invalid proxy URL %q: %w", cfg.Proxy, parseErr)
+			return nil, fmt.Errorf("invalid proxy URL %q: %w", telegramCfg.Proxy, parseErr)
 		}
 		opts = append(opts, telego.WithHTTPClient(&http.Client{
 			Transport: &http.Transport{
@@ -56,15 +61,16 @@ func NewTelegramChannel(cfg config.TelegramConfig, bus *bus.MessageBus) (*Telegr
 		}))
 	}

-	bot, err := telego.NewBot(cfg.Token, opts...)
+	bot, err := telego.NewBot(telegramCfg.Token, opts...)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create telegram bot: %w", err)
 	}

-	base := NewBaseChannel("telegram", cfg, bus, cfg.AllowFrom)
+	base := NewBaseChannel("telegram", telegramCfg, bus, telegramCfg.AllowFrom)

 	return &TelegramChannel{
 		BaseChannel:  base,
+		commands:     NewTelegramCommands(bot, cfg),
 		bot:          bot,
 		config:       cfg,
 		chatIDs:      make(map[string]int64),
@@ -88,31 +94,45 @@ func (c *TelegramChannel) Start(ctx context.Context) error {
 		return fmt.Errorf("failed to start long polling: %w", err)
 	}

+	bh, err := telegohandler.NewBotHandler(c.bot, updates)
+	if err != nil {
+		return fmt.Errorf("failed to create bot handler: %w", err)
+	}
+
+	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
+		c.commands.Help(ctx, message)
+		return nil
+	}, th.CommandEqual("help"))
+	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
+		return c.commands.Start(ctx, message)
+	}, th.CommandEqual("start"))
+
+	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
+		return c.commands.Show(ctx, message)
+	}, th.CommandEqual("show"))
+
+	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
+		return c.commands.List(ctx, message)
+	}, th.CommandEqual("list"))
+
+	bh.HandleMessage(func(ctx *th.Context, message telego.Message) error {
+		return c.handleMessage(ctx, &message)
+	}, th.AnyMessage())
+
 	c.setRunning(true)
 	logger.InfoCF("telegram", "Telegram bot connected", map[string]interface{}{
 		"username": c.bot.Username(),
 	})

+	go bh.Start()
+
 	go func() {
-		for {
-			select {
-			case <-ctx.Done():
-				return
-			case update, ok := <-updates:
-				if !ok {
-					logger.InfoC("telegram", "Updates channel closed, reconnecting...")
-					return
-				}
-				if update.Message != nil {
-					c.handleMessage(ctx, update)
-				}
-			}
-		}
+		<-ctx.Done()
+		bh.Stop()
 	}()

 	return nil
 }
-
 func (c *TelegramChannel) Stop(ctx context.Context) error {
 	logger.InfoC("telegram", "Stopping Telegram bot...")
 	c.setRunning(false)
@@ -166,30 +186,27 @@ func (c *TelegramChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
 	return nil
 }

-func (c *TelegramChannel) handleMessage(ctx context.Context, update telego.Update) {
-	message := update.Message
+func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Message) error {
 	if message == nil {
-		return
+		return fmt.Errorf("message is nil")
 	}

 	user := message.From
 	if user == nil {
-		return
+		return fmt.Errorf("message sender (user) is nil")
 	}

-	userID := fmt.Sprintf("%d", user.ID)
-	senderID := userID
+	senderID := fmt.Sprintf("%d", user.ID)
 	if user.Username != "" {
-		senderID = fmt.Sprintf("%s|%s", userID, user.Username)
+		senderID = fmt.Sprintf("%d|%s", user.ID, user.Username)
 	}

 	// 检查白名单，避免为被拒绝的用户下载附件
-	if !c.IsAllowed(userID) && !c.IsAllowed(senderID) {
+	if !c.IsAllowed(senderID) {
 		logger.DebugCF("telegram", "Message rejected by allowlist", map[string]interface{}{
-			"user_id":  userID,
-			"username": user.Username,
+			"user_id": senderID,
 		})
-		return
+		return nil
 	}

 	chatID := message.Chat.ID
@@ -222,7 +239,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, update telego.Updat
 		content += message.Caption
 	}

-	if message.Photo != nil && len(message.Photo) > 0 {
+	if len(message.Photo) > 0 {
 		photo := message.Photo[len(message.Photo)-1]
 		photoPath := c.downloadPhoto(ctx, photo.FileID)
 		if photoPath != "" {
@@ -231,7 +248,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, update telego.Updat
 			if content != "" {
 				content += "\n"
 			}
-			content += fmt.Sprintf("[image: photo]")
+			content += "[image: photo]"
 		}
 	}

@@ -252,7 +269,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, update telego.Updat
 						"error": err.Error(),
 						"path":  voicePath,
 					})
-					transcribedText = fmt.Sprintf("[voice (transcription failed)]")
+					transcribedText = "[voice (transcription failed)]"
 				} else {
 					transcribedText = fmt.Sprintf("[voice transcription: %s]", result.Text)
 					logger.InfoCF("telegram", "Voice transcribed successfully", map[string]interface{}{
@@ -260,7 +277,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, update telego.Updat
 					})
 				}
 			} else {
-				transcribedText = fmt.Sprintf("[voice]")
+				transcribedText = "[voice]"
 			}

 			if content != "" {
@@ -278,7 +295,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, update telego.Updat
 			if content != "" {
 				content += "\n"
 			}
-			content += fmt.Sprintf("[audio]")
+			content += "[audio]"
 		}
 	}

@@ -290,7 +307,7 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, update telego.Updat
 			if content != "" {
 				content += "\n"
 			}
-			content += fmt.Sprintf("[file]")
+			content += "[file]"
 		}
 	}

@@ -320,37 +337,14 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, update telego.Updat
 		}
 	}

-	// Create new context for thinking animation with timeout
-	thinkCtx, thinkCancel := context.WithTimeout(ctx, 5*time.Minute)
+	// Create cancel function for thinking state
+	_, thinkCancel := context.WithTimeout(ctx, 5*time.Minute)
 	c.stopThinking.Store(chatIDStr, &thinkingCancel{fn: thinkCancel})

 	pMsg, err := c.bot.SendMessage(ctx, tu.Message(tu.ID(chatID), "Thinking... 💭"))
 	if err == nil {
 		pID := pMsg.MessageID
 		c.placeholders.Store(chatIDStr, pID)
-
-		go func(cid int64, mid int) {
-			dots := []string{".", "..", "..."}
-			emotes := []string{"💭", "🤔", "☁️"}
-			i := 0
-			ticker := time.NewTicker(2000 * time.Millisecond)
-			defer ticker.Stop()
-			for {
-				select {
-				case <-thinkCtx.Done():
-					return
-				case <-ticker.C:
-					i++
-					text := fmt.Sprintf("Thinking%s %s", dots[i%len(dots)], emotes[i%len(emotes)])
-					_, editErr := c.bot.EditMessageText(thinkCtx, tu.EditMessageText(tu.ID(chatID), mid, text))
-					if editErr != nil {
-						logger.DebugCF("telegram", "Failed to edit thinking message", map[string]interface{}{
-							"error": editErr.Error(),
-						})
-					}
-				}
-			}
-		}(chatID, pID)
 	}

 	peerKind := "direct"
@@ -370,7 +364,8 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, update telego.Updat
 		"peer_id":    peerID,
 	}

-	c.HandleMessage(senderID, fmt.Sprintf("%d", chatID), content, mediaPaths, metadata)
+	c.HandleMessage(fmt.Sprintf("%d", user.ID), fmt.Sprintf("%d", chatID), content, mediaPaths, metadata)
+	return nil
 }

 func (c *TelegramChannel) downloadPhoto(ctx context.Context, fileID string) string {
@@ -0,0 +1,153 @@
+package channels
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/mymmrac/telego"
+	"github.com/sipeed/picoclaw/pkg/config"
+)
+
+type TelegramCommander interface {
+	Help(ctx context.Context, message telego.Message) error
+	Start(ctx context.Context, message telego.Message) error
+	Show(ctx context.Context, message telego.Message) error
+	List(ctx context.Context, message telego.Message) error
+}
+
+type cmd struct {
+	bot    *telego.Bot
+	config *config.Config
+}
+
+func NewTelegramCommands(bot *telego.Bot, cfg *config.Config) TelegramCommander {
+	return &cmd{
+		bot:    bot,
+		config: cfg,
+	}
+}
+
+func commandArgs(text string) string {
+	parts := strings.SplitN(text, " ", 2)
+	if len(parts) < 2 {
+		return ""
+	}
+	return strings.TrimSpace(parts[1])
+}
+func (c *cmd) Help(ctx context.Context, message telego.Message) error {
+	msg := `/start - Start the bot
+/help - Show this help message
+/show [model|channel] - Show current configuration
+/list [models|channels] - List available options
+	`
+	_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
+		ChatID: telego.ChatID{ID: message.Chat.ID},
+		Text:   msg,
+		ReplyParameters: &telego.ReplyParameters{
+			MessageID: message.MessageID,
+		},
+	})
+	return err
+}
+
+func (c *cmd) Start(ctx context.Context, message telego.Message) error {
+	_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
+		ChatID: telego.ChatID{ID: message.Chat.ID},
+		Text:   "Hello! I am PicoClaw 🦞",
+		ReplyParameters: &telego.ReplyParameters{
+			MessageID: message.MessageID,
+		},
+	})
+	return err
+}
+
+func (c *cmd) Show(ctx context.Context, message telego.Message) error {
+	args := commandArgs(message.Text)
+	if args == "" {
+		_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
+			ChatID: telego.ChatID{ID: message.Chat.ID},
+			Text:   "Usage: /show [model|channel]",
+			ReplyParameters: &telego.ReplyParameters{
+				MessageID: message.MessageID,
+			},
+		})
+		return err
+	}
+
+	var response string
+	switch args {
+	case "model":
+		response = fmt.Sprintf("Current Model: %s (Provider: %s)",
+			c.config.Agents.Defaults.Model,
+			c.config.Agents.Defaults.Provider)
+	case "channel":
+		response = "Current Channel: telegram"
+	default:
+		response = fmt.Sprintf("Unknown parameter: %s. Try 'model' or 'channel'.", args)
+	}
+
+	_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
+		ChatID: telego.ChatID{ID: message.Chat.ID},
+		Text:   response,
+		ReplyParameters: &telego.ReplyParameters{
+			MessageID: message.MessageID,
+		},
+	})
+	return err
+}
+func (c *cmd) List(ctx context.Context, message telego.Message) error {
+	args := commandArgs(message.Text)
+	if args == "" {
+		_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
+			ChatID: telego.ChatID{ID: message.Chat.ID},
+			Text:   "Usage: /list [models|channels]",
+			ReplyParameters: &telego.ReplyParameters{
+				MessageID: message.MessageID,
+			},
+		})
+		return err
+	}
+
+	var response string
+	switch args {
+	case "models":
+		provider := c.config.Agents.Defaults.Provider
+		if provider == "" {
+			provider = "configured default"
+		}
+		response = fmt.Sprintf("Configured Model: %s\nProvider: %s\n\nTo change models, update config.yaml",
+			c.config.Agents.Defaults.Model, provider)
+
+	case "channels":
+		var enabled []string
+		if c.config.Channels.Telegram.Enabled {
+			enabled = append(enabled, "telegram")
+		}
+		if c.config.Channels.WhatsApp.Enabled {
+			enabled = append(enabled, "whatsapp")
+		}
+		if c.config.Channels.Feishu.Enabled {
+			enabled = append(enabled, "feishu")
+		}
+		if c.config.Channels.Discord.Enabled {
+			enabled = append(enabled, "discord")
+		}
+		if c.config.Channels.Slack.Enabled {
+			enabled = append(enabled, "slack")
+		}
+		response = fmt.Sprintf("Enabled Channels:\n- %s", strings.Join(enabled, "\n- "))
+
+	default:
+		response = fmt.Sprintf("Unknown parameter: %s. Try 'models' or 'channels'.", args)
+	}
+
+	_, err := c.bot.SendMessage(ctx, &telego.SendMessageParams{
+		ChatID: telego.ChatID{ID: message.Chat.ID},
+		Text:   response,
+		ReplyParameters: &telego.ReplyParameters{
+			MessageID: message.MessageID,
+		},
+	})
+	return err
+}