x"},
+ {"plain text", "just text", "just text"},
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := markdownToHTML(tt.input)
+ if !strings.Contains(got, tt.contains) {
+ t.Fatalf("markdownToHTML(%q) = %q, want it to contain %q", tt.input, got, tt.contains)
+ }
+ })
+ }
+}
+
+func TestMessageContent(t *testing.T) {
+ richtext := &MatrixChannel{config: config.MatrixConfig{MessageFormat: "richtext"}}
+ plain := &MatrixChannel{config: config.MatrixConfig{MessageFormat: "plain"}}
+ defaultt := &MatrixChannel{config: config.MatrixConfig{}}
+
+ for _, c := range []*MatrixChannel{richtext, defaultt} {
+ mc := c.messageContent("**hi**")
+ if mc.Format != event.FormatHTML {
+ t.Errorf("format %q: expected FormatHTML, got %q", c.config.MessageFormat, mc.Format)
+ }
+ if !strings.Contains(mc.FormattedBody, "hi") {
+ t.Errorf("format %q: FormattedBody %q missing ", c.config.MessageFormat, mc.FormattedBody)
+ }
+ if mc.Body != "**hi**" {
+ t.Errorf("format %q: Body should remain plain, got %q", c.config.MessageFormat, mc.Body)
+ }
+ }
+
+ mc := plain.messageContent("**hi**")
+ if mc.Format != "" || mc.FormattedBody != "" {
+ t.Errorf("plain: expected no formatting, got format=%q formattedBody=%q", mc.Format, mc.FormattedBody)
+ }
+}
diff --git a/pkg/channels/qq/qq.go b/pkg/channels/qq/qq.go
index 540e3b7af..73200f64e 100644
--- a/pkg/channels/qq/qq.go
+++ b/pkg/channels/qq/qq.go
@@ -78,6 +78,7 @@ func (c *QQChannel) Start(ctx context.Context) error {
return fmt.Errorf("QQ app_id and app_secret not configured")
}
+ botgo.SetLogger(logger.NewLogger("botgo"))
logger.InfoC("qq", "Starting QQ bot (WebSocket mode)")
// Reinitialize shutdown signal for clean restart.
diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go
index 024b1b023..3ee849621 100644
--- a/pkg/channels/slack/slack.go
+++ b/pkg/channels/slack/slack.go
@@ -122,7 +122,11 @@ func (c *SlackChannel) Send(ctx context.Context, msg bus.OutboundMessage) error
slack.MsgOptionText(msg.Content, false),
}
- if threadTS != "" {
+ if msg.ReplyToMessageID != "" && threadTS == "" {
+ // Answer to the message by creating a Thread under it
+ opts = append(opts, slack.MsgOptionTS(msg.ReplyToMessageID))
+ } else if threadTS != "" {
+ // If we are already in a thread, continue in the thread
opts = append(opts, slack.MsgOptionTS(threadTS))
}
diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go
index 0a36247a6..34ee46b7b 100644
--- a/pkg/channels/telegram/telegram.go
+++ b/pkg/channels/telegram/telegram.go
@@ -77,6 +77,7 @@ func NewTelegramChannel(cfg *config.Config, bus *bus.MessageBus) (*TelegramChann
if baseURL := strings.TrimRight(strings.TrimSpace(telegramCfg.BaseURL), "/"); baseURL != "" {
opts = append(opts, telego.WithAPIServer(baseURL))
}
+ opts = append(opts, telego.WithLogger(logger.NewLogger("telego")))
bot, err := telego.NewBot(telegramCfg.Token, opts...)
if err != nil {
@@ -168,7 +169,7 @@ func (c *TelegramChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
return channels.ErrNotRunning
}
- chatID, err := parseChatID(msg.ChatID)
+ chatID, threadID, err := parseTelegramChatID(msg.ChatID)
if err != nil {
return fmt.Errorf("invalid chat ID %s: %w", msg.ChatID, channels.ErrSendFailed)
}
@@ -180,6 +181,7 @@ func (c *TelegramChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
// The Manager already splits messages to ≤4000 chars (WithMaxMessageLength),
// so msg.Content is guaranteed to be within that limit. We still need to
// check if HTML expansion pushes it beyond Telegram's 4096-char API limit.
+ replyToID := msg.ReplyToMessageID
queue := []string{msg.Content}
for len(queue) > 0 {
chunk := queue[0]
@@ -200,9 +202,11 @@ func (c *TelegramChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
continue
}
- if err := c.sendHTMLChunk(ctx, chatID, htmlContent, chunk); err != nil {
+ if err := c.sendHTMLChunk(ctx, chatID, threadID, htmlContent, chunk, replyToID); err != nil {
return err
}
+ // Only the first chunk should be a reply; subsequent chunks are normal messages.
+ replyToID = ""
}
return nil
@@ -210,9 +214,20 @@ func (c *TelegramChannel) Send(ctx context.Context, msg bus.OutboundMessage) err
// sendHTMLChunk sends a single HTML message, falling back to the original
// markdown as plain text on parse failure so users never see raw HTML tags.
-func (c *TelegramChannel) sendHTMLChunk(ctx context.Context, chatID int64, htmlContent, mdFallback string) error {
+func (c *TelegramChannel) sendHTMLChunk(
+ ctx context.Context, chatID int64, threadID int, htmlContent, mdFallback string, replyToID string,
+) error {
tgMsg := tu.Message(tu.ID(chatID), htmlContent)
tgMsg.ParseMode = telego.ModeHTML
+ tgMsg.MessageThreadID = threadID
+
+ if replyToID != "" {
+ if mid, parseErr := strconv.Atoi(replyToID); parseErr == nil {
+ tgMsg.ReplyParameters = &telego.ReplyParameters{
+ MessageID: mid,
+ }
+ }
+ }
if _, err := c.bot.SendMessage(ctx, tgMsg); err != nil {
logger.ErrorCF("telegram", "HTML parse failed, falling back to plain text", map[string]any{
@@ -232,13 +247,16 @@ func (c *TelegramChannel) sendHTMLChunk(ctx context.Context, chatID int64, htmlC
// (Telegram's typing indicator expires after ~5s) in a background goroutine.
// The returned stop function is idempotent and cancels the goroutine.
func (c *TelegramChannel) StartTyping(ctx context.Context, chatID string) (func(), error) {
- cid, err := parseChatID(chatID)
+ cid, threadID, err := parseTelegramChatID(chatID)
if err != nil {
return func() {}, err
}
+ action := tu.ChatAction(tu.ID(cid), telego.ChatActionTyping)
+ action.MessageThreadID = threadID
+
// Send the first typing action immediately
- _ = c.bot.SendChatAction(ctx, tu.ChatAction(tu.ID(cid), telego.ChatActionTyping))
+ _ = c.bot.SendChatAction(ctx, action)
typingCtx, cancel := context.WithCancel(ctx)
go func() {
@@ -249,7 +267,9 @@ func (c *TelegramChannel) StartTyping(ctx context.Context, chatID string) (func(
case <-typingCtx.Done():
return
case <-ticker.C:
- _ = c.bot.SendChatAction(typingCtx, tu.ChatAction(tu.ID(cid), telego.ChatActionTyping))
+ a := tu.ChatAction(tu.ID(cid), telego.ChatActionTyping)
+ a.MessageThreadID = threadID
+ _ = c.bot.SendChatAction(typingCtx, a)
}
}
}()
@@ -259,7 +279,7 @@ func (c *TelegramChannel) StartTyping(ctx context.Context, chatID string) (func(
// EditMessage implements channels.MessageEditor.
func (c *TelegramChannel) EditMessage(ctx context.Context, chatID string, messageID string, content string) error {
- cid, err := parseChatID(chatID)
+ cid, _, err := parseTelegramChatID(chatID)
if err != nil {
return err
}
@@ -288,12 +308,14 @@ func (c *TelegramChannel) SendPlaceholder(ctx context.Context, chatID string) (s
text = "Thinking... 💭"
}
- cid, err := parseChatID(chatID)
+ cid, threadID, err := parseTelegramChatID(chatID)
if err != nil {
return "", err
}
- pMsg, err := c.bot.SendMessage(ctx, tu.Message(tu.ID(cid), text))
+ phMsg := tu.Message(tu.ID(cid), text)
+ phMsg.MessageThreadID = threadID
+ pMsg, err := c.bot.SendMessage(ctx, phMsg)
if err != nil {
return "", err
}
@@ -307,7 +329,7 @@ func (c *TelegramChannel) SendMedia(ctx context.Context, msg bus.OutboundMediaMe
return channels.ErrNotRunning
}
- chatID, err := parseChatID(msg.ChatID)
+ chatID, threadID, err := parseTelegramChatID(msg.ChatID)
if err != nil {
return fmt.Errorf("invalid chat ID %s: %w", msg.ChatID, channels.ErrSendFailed)
}
@@ -339,30 +361,34 @@ func (c *TelegramChannel) SendMedia(ctx context.Context, msg bus.OutboundMediaMe
switch part.Type {
case "image":
params := &telego.SendPhotoParams{
- ChatID: tu.ID(chatID),
- Photo: telego.InputFile{File: file},
- Caption: part.Caption,
+ ChatID: tu.ID(chatID),
+ MessageThreadID: threadID,
+ Photo: telego.InputFile{File: file},
+ Caption: part.Caption,
}
_, err = c.bot.SendPhoto(ctx, params)
case "audio":
params := &telego.SendAudioParams{
- ChatID: tu.ID(chatID),
- Audio: telego.InputFile{File: file},
- Caption: part.Caption,
+ ChatID: tu.ID(chatID),
+ MessageThreadID: threadID,
+ Audio: telego.InputFile{File: file},
+ Caption: part.Caption,
}
_, err = c.bot.SendAudio(ctx, params)
case "video":
params := &telego.SendVideoParams{
- ChatID: tu.ID(chatID),
- Video: telego.InputFile{File: file},
- Caption: part.Caption,
+ ChatID: tu.ID(chatID),
+ MessageThreadID: threadID,
+ Video: telego.InputFile{File: file},
+ Caption: part.Caption,
}
_, err = c.bot.SendVideo(ctx, params)
default: // "file" or unknown types
params := &telego.SendDocumentParams{
- ChatID: tu.ID(chatID),
- Document: telego.InputFile{File: file},
- Caption: part.Caption,
+ ChatID: tu.ID(chatID),
+ MessageThreadID: threadID,
+ Document: telego.InputFile{File: file},
+ Caption: part.Caption,
}
_, err = c.bot.SendDocument(ctx, params)
}
@@ -506,19 +532,28 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
content = cleaned
}
+ // For forum topics, embed the thread ID as "chatID/threadID" so replies
+ // route to the correct topic and each topic gets its own session.
+ // Only forum groups (IsForum) are handled; regular group reply threads
+ // must share one session per group.
+ compositeChatID := fmt.Sprintf("%d", chatID)
+ threadID := message.MessageThreadID
+ if message.Chat.IsForum && threadID != 0 {
+ compositeChatID = fmt.Sprintf("%d/%d", chatID, threadID)
+ }
+
logger.DebugCF("telegram", "Received message", map[string]any{
"sender_id": sender.CanonicalID,
- "chat_id": fmt.Sprintf("%d", chatID),
+ "chat_id": compositeChatID,
+ "thread_id": threadID,
"preview": utils.Truncate(content, 50),
})
- // Placeholder is now auto-triggered by BaseChannel.HandleMessage via PlaceholderCapable
-
peerKind := "direct"
peerID := fmt.Sprintf("%d", user.ID)
if message.Chat.Type != "private" {
peerKind = "group"
- peerID = fmt.Sprintf("%d", chatID)
+ peerID = compositeChatID
}
peer := bus.Peer{Kind: peerKind, ID: peerID}
@@ -531,11 +566,17 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes
"is_group": fmt.Sprintf("%t", message.Chat.Type != "private"),
}
+ // Set parent_peer metadata for per-topic agent binding.
+ if message.Chat.IsForum && threadID != 0 {
+ metadata["parent_peer_kind"] = "topic"
+ metadata["parent_peer_id"] = fmt.Sprintf("%d", threadID)
+ }
+
c.HandleMessage(c.ctx,
peer,
messageID,
platformID,
- fmt.Sprintf("%d", chatID),
+ compositeChatID,
content,
mediaPaths,
metadata,
@@ -583,10 +624,23 @@ func (c *TelegramChannel) downloadFile(ctx context.Context, fileID, ext string)
return c.downloadFileWithInfo(file, ext)
}
-func parseChatID(chatIDStr string) (int64, error) {
- var id int64
- _, err := fmt.Sscanf(chatIDStr, "%d", &id)
- return id, err
+// parseTelegramChatID splits "chatID/threadID" into its components.
+// Returns threadID=0 when no "/" is present (non-forum messages).
+func parseTelegramChatID(chatID string) (int64, int, error) {
+ idx := strings.Index(chatID, "/")
+ if idx == -1 {
+ cid, err := strconv.ParseInt(chatID, 10, 64)
+ return cid, 0, err
+ }
+ cid, err := strconv.ParseInt(chatID[:idx], 10, 64)
+ if err != nil {
+ return 0, 0, err
+ }
+ tid, err := strconv.Atoi(chatID[idx+1:])
+ if err != nil {
+ return 0, 0, fmt.Errorf("invalid thread ID in chat ID %q: %w", chatID, err)
+ }
+ return cid, tid, nil
}
func markdownToTelegramHTML(text string) string {
diff --git a/pkg/channels/telegram/telegram_test.go b/pkg/channels/telegram/telegram_test.go
index 3a2f1aa66..c2186d0a3 100644
--- a/pkg/channels/telegram/telegram_test.go
+++ b/pkg/channels/telegram/telegram_test.go
@@ -6,6 +6,7 @@ import (
"errors"
"strings"
"testing"
+ "time"
"github.com/mymmrac/telego"
ta "github.com/mymmrac/telego/telegoapi"
@@ -271,3 +272,191 @@ func TestSend_InvalidChatID(t *testing.T) {
assert.True(t, errors.Is(err, channels.ErrSendFailed), "error should wrap ErrSendFailed")
assert.Empty(t, caller.calls)
}
+
+func TestParseTelegramChatID_Plain(t *testing.T) {
+ cid, tid, err := parseTelegramChatID("12345")
+ assert.NoError(t, err)
+ assert.Equal(t, int64(12345), cid)
+ assert.Equal(t, 0, tid)
+}
+
+func TestParseTelegramChatID_NegativeGroup(t *testing.T) {
+ cid, tid, err := parseTelegramChatID("-1001234567890")
+ assert.NoError(t, err)
+ assert.Equal(t, int64(-1001234567890), cid)
+ assert.Equal(t, 0, tid)
+}
+
+func TestParseTelegramChatID_WithThreadID(t *testing.T) {
+ cid, tid, err := parseTelegramChatID("-1001234567890/42")
+ assert.NoError(t, err)
+ assert.Equal(t, int64(-1001234567890), cid)
+ assert.Equal(t, 42, tid)
+}
+
+func TestParseTelegramChatID_GeneralTopic(t *testing.T) {
+ cid, tid, err := parseTelegramChatID("-100123/1")
+ assert.NoError(t, err)
+ assert.Equal(t, int64(-100123), cid)
+ assert.Equal(t, 1, tid)
+}
+
+func TestParseTelegramChatID_Invalid(t *testing.T) {
+ _, _, err := parseTelegramChatID("not-a-number")
+ assert.Error(t, err)
+}
+
+func TestParseTelegramChatID_InvalidThreadID(t *testing.T) {
+ _, _, err := parseTelegramChatID("-100123/not-a-thread")
+ assert.Error(t, err)
+ assert.Contains(t, err.Error(), "invalid thread ID")
+}
+
+func TestSend_WithForumThreadID(t *testing.T) {
+ caller := &stubCaller{
+ callFn: func(ctx context.Context, url string, data *ta.RequestData) (*ta.Response, error) {
+ return successResponse(t), nil
+ },
+ }
+ ch := newTestChannel(t, caller)
+
+ err := ch.Send(context.Background(), bus.OutboundMessage{
+ ChatID: "-1001234567890/42",
+ Content: "Hello from topic",
+ })
+
+ assert.NoError(t, err)
+ assert.Len(t, caller.calls, 1)
+}
+
+func TestHandleMessage_ForumTopic_SetsMetadata(t *testing.T) {
+ messageBus := bus.NewMessageBus()
+ ch := &TelegramChannel{
+ BaseChannel: channels.NewBaseChannel("telegram", nil, messageBus, nil),
+ chatIDs: make(map[string]int64),
+ ctx: context.Background(),
+ }
+
+ msg := &telego.Message{
+ Text: "hello from topic",
+ MessageID: 10,
+ MessageThreadID: 42,
+ Chat: telego.Chat{
+ ID: -1001234567890,
+ Type: "supergroup",
+ IsForum: true,
+ },
+ From: &telego.User{
+ ID: 7,
+ FirstName: "Alice",
+ },
+ }
+
+ err := ch.handleMessage(context.Background(), msg)
+ require.NoError(t, err)
+
+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+ defer cancel()
+
+ inbound, ok := messageBus.ConsumeInbound(ctx)
+ require.True(t, ok, "expected inbound message")
+
+ // Composite chatID should include thread ID
+ assert.Equal(t, "-1001234567890/42", inbound.ChatID)
+
+ // Peer ID should include thread ID for session key isolation
+ assert.Equal(t, "group", inbound.Peer.Kind)
+ assert.Equal(t, "-1001234567890/42", inbound.Peer.ID)
+
+ // Parent peer metadata should be set for agent binding
+ assert.Equal(t, "topic", inbound.Metadata["parent_peer_kind"])
+ assert.Equal(t, "42", inbound.Metadata["parent_peer_id"])
+}
+
+func TestHandleMessage_NoForum_NoThreadMetadata(t *testing.T) {
+ messageBus := bus.NewMessageBus()
+ ch := &TelegramChannel{
+ BaseChannel: channels.NewBaseChannel("telegram", nil, messageBus, nil),
+ chatIDs: make(map[string]int64),
+ ctx: context.Background(),
+ }
+
+ msg := &telego.Message{
+ Text: "regular group message",
+ MessageID: 11,
+ Chat: telego.Chat{
+ ID: -100999,
+ Type: "group",
+ },
+ From: &telego.User{
+ ID: 8,
+ FirstName: "Bob",
+ },
+ }
+
+ err := ch.handleMessage(context.Background(), msg)
+ require.NoError(t, err)
+
+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+ defer cancel()
+
+ inbound, ok := messageBus.ConsumeInbound(ctx)
+ require.True(t, ok)
+
+ // Plain chatID without thread suffix
+ assert.Equal(t, "-100999", inbound.ChatID)
+
+ // Peer ID should be raw chat ID (no thread suffix)
+ assert.Equal(t, "group", inbound.Peer.Kind)
+ assert.Equal(t, "-100999", inbound.Peer.ID)
+
+ // No parent peer metadata
+ assert.Empty(t, inbound.Metadata["parent_peer_kind"])
+ assert.Empty(t, inbound.Metadata["parent_peer_id"])
+}
+
+func TestHandleMessage_ReplyThread_NonForum_NoIsolation(t *testing.T) {
+ messageBus := bus.NewMessageBus()
+ ch := &TelegramChannel{
+ BaseChannel: channels.NewBaseChannel("telegram", nil, messageBus, nil),
+ chatIDs: make(map[string]int64),
+ ctx: context.Background(),
+ }
+
+ // In regular groups, reply threads set MessageThreadID to the original
+ // message ID. This should NOT trigger per-thread session isolation.
+ msg := &telego.Message{
+ Text: "reply in thread",
+ MessageID: 20,
+ MessageThreadID: 15,
+ Chat: telego.Chat{
+ ID: -100999,
+ Type: "supergroup",
+ IsForum: false,
+ },
+ From: &telego.User{
+ ID: 9,
+ FirstName: "Carol",
+ },
+ }
+
+ err := ch.handleMessage(context.Background(), msg)
+ require.NoError(t, err)
+
+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+ defer cancel()
+
+ inbound, ok := messageBus.ConsumeInbound(ctx)
+ require.True(t, ok)
+
+ // chatID should NOT include thread suffix for non-forum groups
+ assert.Equal(t, "-100999", inbound.ChatID)
+
+ // Peer ID should be raw chat ID (shared session for whole group)
+ assert.Equal(t, "group", inbound.Peer.Kind)
+ assert.Equal(t, "-100999", inbound.Peer.ID)
+
+ // No parent peer metadata
+ assert.Empty(t, inbound.Metadata["parent_peer_kind"])
+ assert.Empty(t, inbound.Metadata["parent_peer_id"])
+}
diff --git a/pkg/channels/wecom/app_test.go b/pkg/channels/wecom/app_test.go
index 7f230494f..7d07041ad 100644
--- a/pkg/channels/wecom/app_test.go
+++ b/pkg/channels/wecom/app_test.go
@@ -209,7 +209,7 @@ func TestWeComAppVerifySignature(t *testing.T) {
}
})
- t.Run("empty token skips verification", func(t *testing.T) {
+ t.Run("empty token rejects verification (fail-closed)", func(t *testing.T) {
cfgEmpty := config.WeComAppConfig{
CorpID: "test_corp_id",
CorpSecret: "test_secret",
@@ -218,8 +218,8 @@ func TestWeComAppVerifySignature(t *testing.T) {
}
chEmpty, _ := NewWeComAppChannel(cfgEmpty, msgBus)
- if !verifySignature(chEmpty.config.Token, "any_sig", "any_ts", "any_nonce", "any_msg") {
- t.Error("empty token should skip verification and return true")
+ if verifySignature(chEmpty.config.Token, "any_sig", "any_ts", "any_nonce", "any_msg") {
+ t.Error("empty token should reject verification (fail-closed)")
}
})
}
diff --git a/pkg/channels/wecom/bot_test.go b/pkg/channels/wecom/bot_test.go
index c053578b1..d223bb6b6 100644
--- a/pkg/channels/wecom/bot_test.go
+++ b/pkg/channels/wecom/bot_test.go
@@ -189,8 +189,7 @@ func TestWeComBotVerifySignature(t *testing.T) {
}
})
- t.Run("empty token skips verification", func(t *testing.T) {
- // Create a channel manually with empty token to test the behavior
+ t.Run("empty token rejects verification (fail-closed)", func(t *testing.T) {
cfgEmpty := config.WeComConfig{
Token: "",
WebhookURL: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test",
@@ -199,8 +198,8 @@ func TestWeComBotVerifySignature(t *testing.T) {
config: cfgEmpty,
}
- if !verifySignature(chEmpty.config.Token, "any_sig", "any_ts", "any_nonce", "any_msg") {
- t.Error("empty token should skip verification and return true")
+ if verifySignature(chEmpty.config.Token, "any_sig", "any_ts", "any_nonce", "any_msg") {
+ t.Error("empty token should reject verification (fail-closed)")
}
})
}
diff --git a/pkg/channels/wecom/common.go b/pkg/channels/wecom/common.go
index 6510e6f81..9a622a2fc 100644
--- a/pkg/channels/wecom/common.go
+++ b/pkg/channels/wecom/common.go
@@ -31,7 +31,7 @@ func computeSignature(token, timestamp, nonce, encrypt string) string {
// This is a common function used by both WeCom Bot and WeCom App
func verifySignature(token, msgSignature, timestamp, nonce, msgEncrypt string) bool {
if token == "" {
- return true // Skip verification if token is not set
+ return false
}
return computeSignature(token, timestamp, nonce, msgEncrypt) == msgSignature
}
diff --git a/pkg/config/config.go b/pkg/config/config.go
index 76d312dae..7a7edb489 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -4,6 +4,7 @@ import (
"encoding/json"
"fmt"
"os"
+ "strings"
"sync/atomic"
"github.com/caarlos0/env/v11"
@@ -16,6 +17,8 @@ var rrCounter atomic.Uint64
// FlexibleStringSlice is a []string that also accepts JSON numbers,
// so allow_from can contain both "123" and 123.
+// It also supports parsing comma-separated strings from environment variables,
+// including both English (,) and Chinese (，) commas.
type FlexibleStringSlice []string
func (f *FlexibleStringSlice) UnmarshalJSON(data []byte) error {
@@ -47,6 +50,30 @@ func (f *FlexibleStringSlice) UnmarshalJSON(data []byte) error {
return nil
}
+// UnmarshalText implements encoding.TextUnmarshaler to support env variable parsing.
+// It handles comma-separated values with both English (,) and Chinese (，) commas.
+func (f *FlexibleStringSlice) UnmarshalText(text []byte) error {
+ if len(text) == 0 {
+ *f = nil
+ return nil
+ }
+
+ s := string(text)
+ // Replace Chinese comma with English comma, then split
+ s = strings.ReplaceAll(s, "，", ",")
+ parts := strings.Split(s, ",")
+
+ result := make([]string, 0, len(parts))
+ for _, part := range parts {
+ part = strings.TrimSpace(part)
+ if part != "" {
+ result = append(result, part)
+ }
+ }
+ *f = result
+ return nil
+}
+
type Config struct {
Agents AgentsConfig `json:"agents"`
Bindings []AgentBinding `json:"bindings,omitempty"`
@@ -58,6 +85,17 @@ type Config struct {
Tools ToolsConfig `json:"tools"`
Heartbeat HeartbeatConfig `json:"heartbeat"`
Devices DevicesConfig `json:"devices"`
+ Voice VoiceConfig `json:"voice"`
+ // BuildInfo contains build-time version information
+ BuildInfo BuildInfo `json:"build_info,omitempty"`
+}
+
+// BuildInfo contains build-time version information
+type BuildInfo struct {
+ Version string `json:"version"`
+ GitCommit string `json:"git_commit"`
+ BuildTime string `json:"build_time"`
+ GoVersion string `json:"go_version"`
}
// MarshalJSON implements custom JSON marshaling for Config
@@ -338,16 +376,17 @@ type SlackConfig struct {
}
type MatrixConfig struct {
- Enabled bool `json:"enabled" env:"PICOCLAW_CHANNELS_MATRIX_ENABLED"`
- Homeserver string `json:"homeserver" env:"PICOCLAW_CHANNELS_MATRIX_HOMESERVER"`
- UserID string `json:"user_id" env:"PICOCLAW_CHANNELS_MATRIX_USER_ID"`
- AccessToken string `json:"access_token" env:"PICOCLAW_CHANNELS_MATRIX_ACCESS_TOKEN"`
- DeviceID string `json:"device_id,omitempty" env:"PICOCLAW_CHANNELS_MATRIX_DEVICE_ID"`
- JoinOnInvite bool `json:"join_on_invite" env:"PICOCLAW_CHANNELS_MATRIX_JOIN_ON_INVITE"`
- AllowFrom FlexibleStringSlice `json:"allow_from" env:"PICOCLAW_CHANNELS_MATRIX_ALLOW_FROM"`
+ Enabled bool `json:"enabled" env:"PICOCLAW_CHANNELS_MATRIX_ENABLED"`
+ Homeserver string `json:"homeserver" env:"PICOCLAW_CHANNELS_MATRIX_HOMESERVER"`
+ UserID string `json:"user_id" env:"PICOCLAW_CHANNELS_MATRIX_USER_ID"`
+ AccessToken string `json:"access_token" env:"PICOCLAW_CHANNELS_MATRIX_ACCESS_TOKEN"`
+ DeviceID string `json:"device_id,omitempty" env:"PICOCLAW_CHANNELS_MATRIX_DEVICE_ID"`
+ JoinOnInvite bool `json:"join_on_invite" env:"PICOCLAW_CHANNELS_MATRIX_JOIN_ON_INVITE"`
+ MessageFormat string `json:"message_format,omitempty" env:"PICOCLAW_CHANNELS_MATRIX_MESSAGE_FORMAT"`
+ AllowFrom FlexibleStringSlice `json:"allow_from" env:"PICOCLAW_CHANNELS_MATRIX_ALLOW_FROM"`
GroupTrigger GroupTriggerConfig `json:"group_trigger,omitempty"`
Placeholder PlaceholderConfig `json:"placeholder,omitempty"`
- ReasoningChannelID string `json:"reasoning_channel_id" env:"PICOCLAW_CHANNELS_MATRIX_REASONING_CHANNEL_ID"`
+ ReasoningChannelID string `json:"reasoning_channel_id" env:"PICOCLAW_CHANNELS_MATRIX_REASONING_CHANNEL_ID"`
}
type LINEConfig struct {
@@ -461,6 +500,10 @@ type DevicesConfig struct {
MonitorUSB bool `json:"monitor_usb" env:"PICOCLAW_DEVICES_MONITOR_USB"`
}
+type VoiceConfig struct {
+ EchoTranscription bool `json:"echo_transcription" env:"PICOCLAW_VOICE_ECHO_TRANSCRIPTION"`
+}
+
type ProvidersConfig struct {
Anthropic ProviderConfig `json:"anthropic"`
OpenAI OpenAIProviderConfig `json:"openai"`
@@ -484,6 +527,7 @@ type ProvidersConfig struct {
Mistral ProviderConfig `json:"mistral"`
Avian ProviderConfig `json:"avian"`
Minimax ProviderConfig `json:"minimax"`
+ LongCat ProviderConfig `json:"longcat"`
}
// IsEmpty checks if all provider configs are empty (no API keys or API bases set)
@@ -510,7 +554,8 @@ func (p ProvidersConfig) IsEmpty() bool {
p.Qwen.APIKey == "" && p.Qwen.APIBase == "" &&
p.Mistral.APIKey == "" && p.Mistral.APIBase == "" &&
p.Avian.APIKey == "" && p.Avian.APIBase == "" &&
- p.Minimax.APIKey == "" && p.Minimax.APIBase == ""
+ p.Minimax.APIKey == "" && p.Minimax.APIBase == "" &&
+ p.LongCat.APIKey == "" && p.LongCat.APIBase == ""
}
// MarshalJSON implements custom JSON marshaling for ProvidersConfig
@@ -593,16 +638,18 @@ type ToolConfig struct {
}
type BraveConfig struct {
- Enabled bool `json:"enabled" env:"PICOCLAW_TOOLS_WEB_BRAVE_ENABLED"`
- APIKey string `json:"api_key" env:"PICOCLAW_TOOLS_WEB_BRAVE_API_KEY"`
- MaxResults int `json:"max_results" env:"PICOCLAW_TOOLS_WEB_BRAVE_MAX_RESULTS"`
+ Enabled bool `json:"enabled" env:"PICOCLAW_TOOLS_WEB_BRAVE_ENABLED"`
+ APIKey string `json:"api_key" env:"PICOCLAW_TOOLS_WEB_BRAVE_API_KEY"`
+ APIKeys []string `json:"api_keys" env:"PICOCLAW_TOOLS_WEB_BRAVE_API_KEYS"`
+ MaxResults int `json:"max_results" env:"PICOCLAW_TOOLS_WEB_BRAVE_MAX_RESULTS"`
}
type TavilyConfig struct {
- Enabled bool `json:"enabled" env:"PICOCLAW_TOOLS_WEB_TAVILY_ENABLED"`
- APIKey string `json:"api_key" env:"PICOCLAW_TOOLS_WEB_TAVILY_API_KEY"`
- BaseURL string `json:"base_url" env:"PICOCLAW_TOOLS_WEB_TAVILY_BASE_URL"`
- MaxResults int `json:"max_results" env:"PICOCLAW_TOOLS_WEB_TAVILY_MAX_RESULTS"`
+ Enabled bool `json:"enabled" env:"PICOCLAW_TOOLS_WEB_TAVILY_ENABLED"`
+ APIKey string `json:"api_key" env:"PICOCLAW_TOOLS_WEB_TAVILY_API_KEY"`
+ APIKeys []string `json:"api_keys" env:"PICOCLAW_TOOLS_WEB_TAVILY_API_KEYS"`
+ BaseURL string `json:"base_url" env:"PICOCLAW_TOOLS_WEB_TAVILY_BASE_URL"`
+ MaxResults int `json:"max_results" env:"PICOCLAW_TOOLS_WEB_TAVILY_MAX_RESULTS"`
}
type DuckDuckGoConfig struct {
@@ -611,9 +658,10 @@ type DuckDuckGoConfig struct {
}
type PerplexityConfig struct {
- Enabled bool `json:"enabled" env:"PICOCLAW_TOOLS_WEB_PERPLEXITY_ENABLED"`
- APIKey string `json:"api_key" env:"PICOCLAW_TOOLS_WEB_PERPLEXITY_API_KEY"`
- MaxResults int `json:"max_results" env:"PICOCLAW_TOOLS_WEB_PERPLEXITY_MAX_RESULTS"`
+ Enabled bool `json:"enabled" env:"PICOCLAW_TOOLS_WEB_PERPLEXITY_ENABLED"`
+ APIKey string `json:"api_key" env:"PICOCLAW_TOOLS_WEB_PERPLEXITY_API_KEY"`
+ APIKeys []string `json:"api_keys" env:"PICOCLAW_TOOLS_WEB_PERPLEXITY_API_KEYS"`
+ MaxResults int `json:"max_results" env:"PICOCLAW_TOOLS_WEB_PERPLEXITY_MAX_RESULTS"`
}
type SearXNGConfig struct {
@@ -654,6 +702,7 @@ type CronToolsConfig struct {
type ExecConfig struct {
ToolConfig ` envPrefix:"PICOCLAW_TOOLS_EXEC_"`
EnableDenyPatterns bool ` env:"PICOCLAW_TOOLS_EXEC_ENABLE_DENY_PATTERNS" json:"enable_deny_patterns"`
+ AllowRemote bool ` env:"PICOCLAW_TOOLS_EXEC_ALLOW_REMOTE" json:"allow_remote"`
CustomDenyPatterns []string ` env:"PICOCLAW_TOOLS_EXEC_CUSTOM_DENY_PATTERNS" json:"custom_deny_patterns"`
CustomAllowPatterns []string ` env:"PICOCLAW_TOOLS_EXEC_CUSTOM_ALLOW_PATTERNS" json:"custom_allow_patterns"`
TimeoutSeconds int ` env:"PICOCLAW_TOOLS_EXEC_TIMEOUT_SECONDS" json:"timeout_seconds"` // 0 means use default (60s)
@@ -933,6 +982,29 @@ func (c *Config) ValidateModelList() error {
return nil
}
+func MergeAPIKeys(apiKey string, apiKeys []string) []string {
+ seen := make(map[string]struct{})
+ var all []string
+
+ if k := strings.TrimSpace(apiKey); k != "" {
+ if _, exists := seen[k]; !exists {
+ seen[k] = struct{}{}
+ all = append(all, k)
+ }
+ }
+
+ for _, k := range apiKeys {
+ if trimmed := strings.TrimSpace(k); trimmed != "" {
+ if _, exists := seen[trimmed]; !exists {
+ seen[trimmed] = struct{}{}
+ all = append(all, trimmed)
+ }
+ }
+ }
+
+ return all
+}
+
func (t *ToolsConfig) IsToolEnabled(name string) bool {
switch name {
case "web":
diff --git a/pkg/config/config_test.go b/pkg/config/config_test.go
index 47f79c6f0..ad89d6d2e 100644
--- a/pkg/config/config_test.go
+++ b/pkg/config/config_test.go
@@ -296,7 +296,7 @@ func TestDefaultConfig_WebTools(t *testing.T) {
if cfg.Tools.Web.Brave.MaxResults != 5 {
t.Error("Expected Brave MaxResults 5, got ", cfg.Tools.Web.Brave.MaxResults)
}
- if cfg.Tools.Web.Brave.APIKey != "" {
+ if len(cfg.Tools.Web.Brave.APIKeys) != 0 {
t.Error("Brave API key should be empty by default")
}
if cfg.Tools.Web.DuckDuckGo.MaxResults != 5 {
@@ -384,6 +384,13 @@ func TestDefaultConfig_OpenAIWebSearchEnabled(t *testing.T) {
}
}
+func TestDefaultConfig_ExecAllowRemoteEnabled(t *testing.T) {
+ cfg := DefaultConfig()
+ if !cfg.Tools.Exec.AllowRemote {
+ t.Fatal("DefaultConfig().Tools.Exec.AllowRemote should be true")
+ }
+}
+
func TestLoadConfig_OpenAIWebSearchDefaultsTrueWhenUnset(t *testing.T) {
dir := t.TempDir()
configPath := filepath.Join(dir, "config.json")
@@ -400,6 +407,22 @@ func TestLoadConfig_OpenAIWebSearchDefaultsTrueWhenUnset(t *testing.T) {
}
}
+func TestLoadConfig_ExecAllowRemoteDefaultsTrueWhenUnset(t *testing.T) {
+ dir := t.TempDir()
+ configPath := filepath.Join(dir, "config.json")
+ if err := os.WriteFile(configPath, []byte(`{"tools":{"exec":{"enable_deny_patterns":true}}}`), 0o600); err != nil {
+ t.Fatalf("WriteFile() error: %v", err)
+ }
+
+ cfg, err := LoadConfig(configPath)
+ if err != nil {
+ t.Fatalf("LoadConfig() error: %v", err)
+ }
+ if !cfg.Tools.Exec.AllowRemote {
+ t.Fatal("tools.exec.allow_remote should remain true when unset in config file")
+ }
+}
+
func TestLoadConfig_OpenAIWebSearchCanBeDisabled(t *testing.T) {
dir := t.TempDir()
configPath := filepath.Join(dir, "config.json")
@@ -482,3 +505,119 @@ func TestDefaultConfig_WorkspacePath_WithPicoclawHome(t *testing.T) {
t.Errorf("Workspace path with PICOCLAW_HOME = %q, want %q", cfg.Agents.Defaults.Workspace, want)
}
}
+
+// TestFlexibleStringSlice_UnmarshalText tests UnmarshalText with various comma separators
+func TestFlexibleStringSlice_UnmarshalText(t *testing.T) {
+ tests := []struct {
+ name string
+ input string
+ expected []string
+ }{
+ {
+ name: "English commas only",
+ input: "123,456,789",
+ expected: []string{"123", "456", "789"},
+ },
+ {
+ name: "Chinese commas only",
+ input: "123，456，789",
+ expected: []string{"123", "456", "789"},
+ },
+ {
+ name: "Mixed English and Chinese commas",
+ input: "123,456，789",
+ expected: []string{"123", "456", "789"},
+ },
+ {
+ name: "Single value",
+ input: "123",
+ expected: []string{"123"},
+ },
+ {
+ name: "Values with whitespace",
+ input: " 123 , 456 , 789 ",
+ expected: []string{"123", "456", "789"},
+ },
+ {
+ name: "Empty string",
+ input: "",
+ expected: nil,
+ },
+ {
+ name: "Only commas - English",
+ input: ",,",
+ expected: []string{},
+ },
+ {
+ name: "Only commas - Chinese",
+ input: "，，",
+ expected: []string{},
+ },
+ {
+ name: "Mixed commas with empty parts",
+ input: "123,,456，，789",
+ expected: []string{"123", "456", "789"},
+ },
+ {
+ name: "Complex mixed values",
+ input: "user1@example.com，user2@test.com, admin@domain.org",
+ expected: []string{"user1@example.com", "user2@test.com", "admin@domain.org"},
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ var f FlexibleStringSlice
+ err := f.UnmarshalText([]byte(tt.input))
+ if err != nil {
+ t.Fatalf("UnmarshalText(%q) error = %v", tt.input, err)
+ }
+
+ if tt.expected == nil {
+ if f != nil {
+ t.Errorf("UnmarshalText(%q) = %v, want nil", tt.input, f)
+ }
+ return
+ }
+
+ if len(f) != len(tt.expected) {
+ t.Errorf("UnmarshalText(%q) length = %d, want %d", tt.input, len(f), len(tt.expected))
+ return
+ }
+
+ for i, v := range tt.expected {
+ if f[i] != v {
+ t.Errorf("UnmarshalText(%q)[%d] = %q, want %q", tt.input, i, f[i], v)
+ }
+ }
+ })
+ }
+}
+
+// TestFlexibleStringSlice_UnmarshalText_EmptySliceConsistency tests nil vs empty slice behavior
+func TestFlexibleStringSlice_UnmarshalText_EmptySliceConsistency(t *testing.T) {
+ t.Run("Empty string returns nil", func(t *testing.T) {
+ var f FlexibleStringSlice
+ err := f.UnmarshalText([]byte(""))
+ if err != nil {
+ t.Fatalf("UnmarshalText error = %v", err)
+ }
+ if f != nil {
+ t.Errorf("Empty string should return nil, got %v", f)
+ }
+ })
+
+ t.Run("Commas only returns empty slice", func(t *testing.T) {
+ var f FlexibleStringSlice
+ err := f.UnmarshalText([]byte(",,,"))
+ if err != nil {
+ t.Fatalf("UnmarshalText error = %v", err)
+ }
+ if f == nil {
+ t.Error("Commas only should return empty slice, not nil")
+ }
+ if len(f) != 0 {
+ t.Errorf("Expected empty slice, got %v", f)
+ }
+ })
+}
diff --git a/pkg/config/defaults.go b/pkg/config/defaults.go
index 0892d45f4..492b22e3a 100644
--- a/pkg/config/defaults.go
+++ b/pkg/config/defaults.go
@@ -355,6 +355,14 @@ func DefaultConfig() *Config {
APIKey: "",
},
+ // LongCat - https://longcat.chat/platform
+ {
+ ModelName: "LongCat-Flash-Thinking",
+ Model: "longcat/LongCat-Flash-Thinking",
+ APIBase: "https://api.longcat.chat/openai",
+ APIKey: "",
+ },
+
// VLLM (local) - http://localhost:8000
{
ModelName: "local-model",
@@ -384,6 +392,13 @@ func DefaultConfig() *Config {
Brave: BraveConfig{
Enabled: false,
APIKey: "",
+ APIKeys: nil,
+ MaxResults: 5,
+ },
+ Tavily: TavilyConfig{
+ Enabled: false,
+ APIKey: "",
+ APIKeys: nil,
MaxResults: 5,
},
DuckDuckGo: DuckDuckGoConfig{
@@ -393,6 +408,7 @@ func DefaultConfig() *Config {
Perplexity: PerplexityConfig{
Enabled: false,
APIKey: "",
+ APIKeys: nil,
MaxResults: 5,
},
SearXNG: SearXNGConfig{
@@ -419,6 +435,7 @@ func DefaultConfig() *Config {
Enabled: true,
},
EnableDenyPatterns: true,
+ AllowRemote: true,
TimeoutSeconds: 60,
},
Skills: SkillsToolsConfig{
@@ -502,5 +519,14 @@ func DefaultConfig() *Config {
Enabled: false,
MonitorUSB: true,
},
+ Voice: VoiceConfig{
+ EchoTranscription: false,
+ },
+ BuildInfo: BuildInfo{
+ Version: Version,
+ GitCommit: GitCommit,
+ BuildTime: BuildTime,
+ GoVersion: GoVersion,
+ },
}
}
diff --git a/pkg/config/migration.go b/pkg/config/migration.go
index 51f21e4f4..8e693506b 100644
--- a/pkg/config/migration.go
+++ b/pkg/config/migration.go
@@ -407,6 +407,23 @@ func ConvertProvidersToModelList(cfg *Config) []ModelConfig {
}, true
},
},
+ {
+ providerNames: []string{"longcat"},
+ protocol: "longcat",
+ buildConfig: func(p ProvidersConfig) (ModelConfig, bool) {
+ if p.LongCat.APIKey == "" && p.LongCat.APIBase == "" {
+ return ModelConfig{}, false
+ }
+ return ModelConfig{
+ ModelName: "longcat",
+ Model: "longcat/LongCat-Flash-Thinking",
+ APIKey: p.LongCat.APIKey,
+ APIBase: p.LongCat.APIBase,
+ Proxy: p.LongCat.Proxy,
+ RequestTimeout: p.LongCat.RequestTimeout,
+ }, true
+ },
+ },
}
// Process each provider migration
diff --git a/pkg/config/migration_test.go b/pkg/config/migration_test.go
index d3019aab0..807d93e49 100644
--- a/pkg/config/migration_test.go
+++ b/pkg/config/migration_test.go
@@ -162,14 +162,15 @@ func TestConvertProvidersToModelList_AllProviders(t *testing.T) {
Qwen: ProviderConfig{APIKey: "key17"},
Mistral: ProviderConfig{APIKey: "key18"},
Avian: ProviderConfig{APIKey: "key19"},
+ LongCat: ProviderConfig{APIKey: "key-longcat"},
},
}
result := ConvertProvidersToModelList(cfg)
- // All 21 providers should be converted
- if len(result) != 21 {
- t.Errorf("len(result) = %d, want 21", len(result))
+ // All 22 providers should be converted
+ if len(result) != 22 {
+ t.Errorf("len(result) = %d, want 22", len(result))
}
}
diff --git a/pkg/config/version.go b/pkg/config/version.go
new file mode 100644
index 000000000..b65d3cf33
--- /dev/null
+++ b/pkg/config/version.go
@@ -0,0 +1,44 @@
+package config
+
+import (
+ "fmt"
+ "runtime"
+)
+
+// Build-time variables injected via ldflags during build process.
+// These are set by the Makefile or .goreleaser.yaml using the -X flag:
+//
+// -X github.com/sipeed/picoclaw/pkg/config.Version=+ {t("pages.agent.skills.description")} +
+ + {data?.skills.length ? ( ++ {t("pages.agent.tools.description")} +
+ + {data?.tools.length ? ( + groupedTools.map(([category, items]) => ( +- {t("pages.logs.description")} -
++ {t("pages.logs.description")} +
+