From 89af3b251137698cfc0be6d284a323c21301dd31 Mon Sep 17 00:00:00 2001 From: smallwhite Date: Mon, 30 Mar 2026 15:01:01 +0800 Subject: [PATCH 001/174] fix(tools): message tool no longer suppresses reply to originating chat When the message tool sent to a different chat (e.g., a group), the agent's final response to the originating chat was incorrectly skipped because HasSentInRound() was a simple bool that didn't distinguish targets. Replace with HasSentTo(channel, chatID) that tracks all send targets per round and only suppresses when the target matches. Fixes cross-conversation message causing "Processing..." to hang. --- pkg/agent/loop.go | 10 +++++----- pkg/tools/message.go | 38 +++++++++++++++++++++++++++++++++----- 2 files changed, 38 insertions(+), 10 deletions(-) diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go index ef2951365..a32d8d5bf 100644 --- a/pkg/agent/loop.go +++ b/pkg/agent/loop.go @@ -608,21 +608,21 @@ func (al *AgentLoop) PublishResponseIfNeeded(ctx context.Context, channel, chatI return } - alreadySent := false + alreadySentToSameChat := false defaultAgent := al.GetRegistry().GetDefaultAgent() if defaultAgent != nil { if tool, ok := defaultAgent.Tools.Get("message"); ok { if mt, ok := tool.(*tools.MessageTool); ok { - alreadySent = mt.HasSentInRound() + alreadySentToSameChat = mt.HasSentTo(channel, chatID) } } } - if alreadySent { + if alreadySentToSameChat { logger.DebugCF( "agent", - "Skipped outbound (message tool already sent)", - map[string]any{"channel": channel}, + "Skipped outbound (message tool already sent to same chat)", + map[string]any{"channel": channel, "chat_id": chatID}, ) return } diff --git a/pkg/tools/message.go b/pkg/tools/message.go index 438ceeddd..e20edbd20 100644 --- a/pkg/tools/message.go +++ b/pkg/tools/message.go @@ -3,14 +3,21 @@ package tools import ( "context" "fmt" - "sync/atomic" + "sync" ) type SendCallback func(channel, chatID, content string) error +// sentTarget records the channel+chatID that the message tool sent to. +type sentTarget struct { + Channel string + ChatID string +} + type MessageTool struct { sendCallback SendCallback - sentInRound atomic.Bool // Tracks whether a message was sent in the current processing round + mu sync.Mutex + sentTargets []sentTarget // Tracks all targets sent to in the current round } func NewMessageTool() *MessageTool { @@ -49,12 +56,30 @@ func (t *MessageTool) Parameters() map[string]any { // ResetSentInRound resets the per-round send tracker. // Called by the agent loop at the start of each inbound message processing round. func (t *MessageTool) ResetSentInRound() { - t.sentInRound.Store(false) + t.mu.Lock() + t.sentTargets = t.sentTargets[:0] + t.mu.Unlock() } // HasSentInRound returns true if the message tool sent a message during the current round. func (t *MessageTool) HasSentInRound() bool { - return t.sentInRound.Load() + t.mu.Lock() + defer t.mu.Unlock() + return len(t.sentTargets) > 0 +} + +// HasSentTo returns true if the message tool sent to the specific channel+chatID +// during the current round. Used by PublishResponseIfNeeded to avoid suppressing +// the final response when the message tool only sent to a different conversation. +func (t *MessageTool) HasSentTo(channel, chatID string) bool { + t.mu.Lock() + defer t.mu.Unlock() + for _, st := range t.sentTargets { + if st.Channel == channel && st.ChatID == chatID { + return true + } + } + return false } func (t *MessageTool) SetSendCallback(callback SendCallback) { @@ -93,7 +118,10 @@ func (t *MessageTool) Execute(ctx context.Context, args map[string]any) *ToolRes } } - t.sentInRound.Store(true) + t.mu.Lock() + t.sentTargets = append(t.sentTargets, sentTarget{Channel: channel, ChatID: chatID}) + t.mu.Unlock() + // Silent: user already received the message directly return &ToolResult{ ForLLM: fmt.Sprintf("Message sent to %s:%s", channel, chatID), From 9cfa3c3ba61e25eb8c83d53d226074fc42b45c2d Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 13:35:18 +0800 Subject: [PATCH 002/174] refactor(inbound): add inbound context compatibility bridge --- pkg/agent/loop.go | 3 + pkg/bus/bus.go | 1 + pkg/bus/bus_test.go | 120 +++++++++++++++++ pkg/bus/inbound_context.go | 264 +++++++++++++++++++++++++++++++++++++ pkg/bus/types.go | 28 ++++ pkg/channels/base.go | 1 + 6 files changed, 417 insertions(+) create mode 100644 pkg/bus/inbound_context.go diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go index d7461e76f..84b783985 100644 --- a/pkg/agent/loop.go +++ b/pkg/agent/loop.go @@ -1241,6 +1241,7 @@ func (al *AgentLoop) ProcessDirectWithChannel( Content: content, SessionKey: sessionKey, } + msg.Context = bus.ContextFromLegacyInbound(msg) return al.processMessage(ctx, msg) } @@ -1276,6 +1277,8 @@ func (al *AgentLoop) ProcessHeartbeat( } func (al *AgentLoop) processMessage(ctx context.Context, msg bus.InboundMessage) (string, error) { + msg = bus.NormalizeInboundMessage(msg) + // Add message preview to log (show full content for error messages) var logContent string if strings.Contains(msg.Content, "Error:") || strings.Contains(msg.Content, "error") { diff --git a/pkg/bus/bus.go b/pkg/bus/bus.go index 37fcb74c5..f6a339ff0 100644 --- a/pkg/bus/bus.go +++ b/pkg/bus/bus.go @@ -80,6 +80,7 @@ func publish[T any](ctx context.Context, mb *MessageBus, ch chan T, msg T) error } func (mb *MessageBus) PublishInbound(ctx context.Context, msg InboundMessage) error { + msg = NormalizeInboundMessage(msg) return publish(ctx, mb, mb.inbound, msg) } diff --git a/pkg/bus/bus_test.go b/pkg/bus/bus_test.go index 9b6324ca6..ab79c0d49 100644 --- a/pkg/bus/bus_test.go +++ b/pkg/bus/bus_test.go @@ -34,6 +34,126 @@ func TestPublishConsume(t *testing.T) { if got.Channel != "test" { t.Fatalf("expected channel 'test', got %q", got.Channel) } + if got.Context.Channel != "test" { + t.Fatalf("expected context channel 'test', got %q", got.Context.Channel) + } + if got.Context.ChatID != "chat1" { + t.Fatalf("expected context chat ID 'chat1', got %q", got.Context.ChatID) + } + if got.Context.SenderID != "user1" { + t.Fatalf("expected context sender ID 'user1', got %q", got.Context.SenderID) + } +} + +func TestPublishInbound_NormalizesLegacyFieldsIntoContext(t *testing.T) { + mb := NewMessageBus() + defer mb.Close() + + msg := InboundMessage{ + Channel: "slack", + SenderID: "U123", + ChatID: "C456/1712", + Content: "hello", + MessageID: "1712.01", + Peer: Peer{Kind: "group", ID: "C456"}, + Metadata: map[string]string{ + "account_id": "workspace-a", + "team_id": "T001", + "reply_to_message_id": "1700.01", + "is_mentioned": "true", + "parent_peer_kind": "topic", + "parent_peer_id": "1712", + }, + } + + if err := mb.PublishInbound(context.Background(), msg); err != nil { + t.Fatalf("PublishInbound failed: %v", err) + } + + got := <-mb.InboundChan() + if got.Context.Channel != "slack" { + t.Fatalf("expected context channel slack, got %q", got.Context.Channel) + } + if got.Context.Account != "workspace-a" { + t.Fatalf("expected context account workspace-a, got %q", got.Context.Account) + } + if got.Context.ChatType != "group" { + t.Fatalf("expected context chat type group, got %q", got.Context.ChatType) + } + if got.Context.TopicID != "1712" { + t.Fatalf("expected topic 1712, got %q", got.Context.TopicID) + } + if got.Context.SpaceType != "team" || got.Context.SpaceID != "T001" { + t.Fatalf("expected team space T001, got %q/%q", got.Context.SpaceType, got.Context.SpaceID) + } + if !got.Context.Mentioned { + t.Fatal("expected mentioned=true in context") + } + if got.Context.ReplyToMessageID != "1700.01" { + t.Fatalf("expected reply_to_message_id 1700.01, got %q", got.Context.ReplyToMessageID) + } +} + +func TestPublishInbound_MirrorsContextIntoLegacyFields(t *testing.T) { + mb := NewMessageBus() + defer mb.Close() + + msg := InboundMessage{ + Context: InboundContext{ + Channel: "telegram", + Account: "bot-a", + ChatID: "-1001", + ChatType: "group", + TopicID: "42", + SpaceID: "guild-9", + SpaceType: "guild", + SenderID: "user-1", + MessageID: "777", + Mentioned: true, + ReplyToMessageID: "666", + }, + Content: "hi", + } + + if err := mb.PublishInbound(context.Background(), msg); err != nil { + t.Fatalf("PublishInbound failed: %v", err) + } + + got := <-mb.InboundChan() + if got.Channel != "telegram" { + t.Fatalf("expected legacy channel telegram, got %q", got.Channel) + } + if got.ChatID != "-1001" { + t.Fatalf("expected legacy chat ID -1001, got %q", got.ChatID) + } + if got.SenderID != "user-1" { + t.Fatalf("expected legacy sender ID user-1, got %q", got.SenderID) + } + if got.MessageID != "777" { + t.Fatalf("expected legacy message ID 777, got %q", got.MessageID) + } + if got.Peer.Kind != "group" || got.Peer.ID != "-1001" { + t.Fatalf("expected legacy peer group/-1001, got %q/%q", got.Peer.Kind, got.Peer.ID) + } + if got.Metadata["account_id"] != "bot-a" { + t.Fatalf("expected mirrored account_id bot-a, got %q", got.Metadata["account_id"]) + } + if got.Metadata["guild_id"] != "guild-9" { + t.Fatalf("expected mirrored guild_id guild-9, got %q", got.Metadata["guild_id"]) + } + if got.Metadata["parent_peer_kind"] != "topic" || got.Metadata["parent_peer_id"] != "42" { + t.Fatalf( + "expected mirrored topic parent peer, got %q/%q", + got.Metadata["parent_peer_kind"], + got.Metadata["parent_peer_id"], + ) + } + if got.Metadata["reply_to_message_id"] != "666" { + t.Fatalf("expected mirrored reply_to_message_id 666, got %q", got.Metadata["reply_to_message_id"]) + } + if got.Metadata["is_mentioned"] != "true" { + t.Fatalf("expected mirrored is_mentioned true, got %q", got.Metadata["is_mentioned"]) + } } func TestPublishOutboundSubscribe(t *testing.T) { diff --git a/pkg/bus/inbound_context.go b/pkg/bus/inbound_context.go new file mode 100644 index 000000000..501f27be4 --- /dev/null +++ b/pkg/bus/inbound_context.go @@ -0,0 +1,264 @@ +package bus + +import "strings" + +const ( + metadataKeyAccountID = "account_id" + metadataKeyGuildID = "guild_id" + metadataKeyTeamID = "team_id" + metadataKeyReplyToMessage = "reply_to_message_id" + metadataKeyReplyToSender = "reply_to_sender_id" + metadataKeyParentPeerKind = "parent_peer_kind" + metadataKeyParentPeerID = "parent_peer_id" + metadataKeyIsMentioned = "is_mentioned" +) + +// ContextFromLegacyInbound builds a normalized inbound context from the legacy +// top-level fields on InboundMessage. This keeps older producers working while +// new producers migrate to writing Context directly. +func ContextFromLegacyInbound(msg InboundMessage) InboundContext { + ctx := InboundContext{ + Channel: strings.TrimSpace(msg.Channel), + ChatID: strings.TrimSpace(msg.ChatID), + ChatType: normalizeKind(msg.Peer.Kind), + SenderID: firstNonEmpty( + strings.TrimSpace(msg.SenderID), + strings.TrimSpace(msg.Sender.CanonicalID), + strings.TrimSpace(msg.Sender.PlatformID), + ), + MessageID: strings.TrimSpace(msg.MessageID), + Raw: cloneStringMap(msg.Metadata), + } + + if account := metadataValue(msg.Metadata, metadataKeyAccountID); account != "" { + ctx.Account = account + } + if replyToMsgID := metadataValue(msg.Metadata, metadataKeyReplyToMessage); replyToMsgID != "" { + ctx.ReplyToMessageID = replyToMsgID + } + if replyToSenderID := metadataValue(msg.Metadata, metadataKeyReplyToSender); replyToSenderID != "" { + ctx.ReplyToSenderID = replyToSenderID + } + if isTruthy(metadataValue(msg.Metadata, metadataKeyIsMentioned)) { + ctx.Mentioned = true + } + + parentKind := normalizeKind(metadataValue(msg.Metadata, metadataKeyParentPeerKind)) + parentID := metadataValue(msg.Metadata, metadataKeyParentPeerID) + if parentKind == "topic" && parentID != "" { + ctx.TopicID = parentID + } + + switch { + case metadataValue(msg.Metadata, metadataKeyGuildID) != "": + ctx.SpaceType = "guild" + ctx.SpaceID = metadataValue(msg.Metadata, metadataKeyGuildID) + case metadataValue(msg.Metadata, metadataKeyTeamID) != "": + ctx.SpaceType = "team" + ctx.SpaceID = metadataValue(msg.Metadata, metadataKeyTeamID) + } + + return normalizeInboundContext(ctx) +} + +// NormalizeInboundMessage ensures the normalized Context is present and mirrors +// missing legacy fields from it so older consumers continue to work during the +// migration period. +func NormalizeInboundMessage(msg InboundMessage) InboundMessage { + if msg.Context.isZero() { + msg.Context = ContextFromLegacyInbound(msg) + } else { + msg.Context = normalizeInboundContext(msg.Context) + } + + if msg.Channel == "" { + msg.Channel = msg.Context.Channel + } + if msg.SenderID == "" { + msg.SenderID = msg.Context.SenderID + } + if msg.ChatID == "" { + msg.ChatID = msg.Context.ChatID + } + if msg.MessageID == "" { + msg.MessageID = msg.Context.MessageID + } + if msg.Peer.Kind == "" { + msg.Peer = peerFromContext(msg.Context) + } + + msg.Metadata = mergeLegacyMetadata(msg.Metadata, msg.Context) + return msg +} + +func (ctx InboundContext) isZero() bool { + return ctx.Channel == "" && + ctx.Account == "" && + ctx.ChatID == "" && + ctx.ChatType == "" && + ctx.TopicID == "" && + ctx.SpaceID == "" && + ctx.SpaceType == "" && + ctx.SenderID == "" && + ctx.MessageID == "" && + !ctx.Mentioned && + ctx.ReplyToMessageID == "" && + ctx.ReplyToSenderID == "" && + len(ctx.ReplyHandles) == 0 && + len(ctx.Raw) == 0 +} + +func normalizeInboundContext(ctx InboundContext) InboundContext { + ctx.Channel = strings.TrimSpace(ctx.Channel) + ctx.Account = strings.TrimSpace(ctx.Account) + ctx.ChatID = strings.TrimSpace(ctx.ChatID) + ctx.ChatType = normalizeKind(ctx.ChatType) + ctx.TopicID = strings.TrimSpace(ctx.TopicID) + ctx.SpaceID = strings.TrimSpace(ctx.SpaceID) + ctx.SpaceType = normalizeKind(ctx.SpaceType) + ctx.SenderID = strings.TrimSpace(ctx.SenderID) + ctx.MessageID = strings.TrimSpace(ctx.MessageID) + ctx.ReplyToMessageID = strings.TrimSpace(ctx.ReplyToMessageID) + ctx.ReplyToSenderID = strings.TrimSpace(ctx.ReplyToSenderID) + ctx.ReplyHandles = cloneStringMap(ctx.ReplyHandles) + ctx.Raw = cloneStringMap(ctx.Raw) + return ctx +} + +func peerFromContext(ctx InboundContext) Peer { + kind := normalizeKind(ctx.ChatType) + if kind == "" { + return Peer{} + } + + switch kind { + case "direct": + return Peer{ + Kind: "direct", + ID: firstNonEmpty(strings.TrimSpace(ctx.SenderID), strings.TrimSpace(ctx.ChatID)), + } + case "group", "channel": + return Peer{ + Kind: kind, + ID: strings.TrimSpace(ctx.ChatID), + } + default: + return Peer{ + Kind: kind, + ID: strings.TrimSpace(ctx.ChatID), + } + } +} + +func mergeLegacyMetadata(existing map[string]string, ctx InboundContext) map[string]string { + merged := cloneStringMap(existing) + if len(merged) == 0 { + merged = cloneStringMap(ctx.Raw) + } else { + for k, v := range ctx.Raw { + if _, ok := merged[k]; !ok { + merged[k] = v + } + } + } + + if ctx.Account != "" { + if merged == nil { + merged = make(map[string]string) + } + setMissing(merged, metadataKeyAccountID, ctx.Account) + } + if ctx.ReplyToMessageID != "" { + if merged == nil { + merged = make(map[string]string) + } + setMissing(merged, metadataKeyReplyToMessage, ctx.ReplyToMessageID) + } + if ctx.ReplyToSenderID != "" { + if merged == nil { + merged = make(map[string]string) + } + setMissing(merged, metadataKeyReplyToSender, ctx.ReplyToSenderID) + } + if ctx.Mentioned { + if merged == nil { + merged = make(map[string]string) + } + setMissing(merged, metadataKeyIsMentioned, "true") + } + if ctx.TopicID != "" { + if merged == nil { + merged = make(map[string]string) + } + setMissing(merged, metadataKeyParentPeerKind, "topic") + setMissing(merged, metadataKeyParentPeerID, ctx.TopicID) + } + + switch normalizeKind(ctx.SpaceType) { + case "guild": + if merged == nil { + merged = make(map[string]string) + } + setMissing(merged, metadataKeyGuildID, ctx.SpaceID) + case "team", "workspace": + if merged == nil { + merged = make(map[string]string) + } + setMissing(merged, metadataKeyTeamID, ctx.SpaceID) + } + + if len(merged) == 0 { + return nil + } + return merged +} + +func setMissing(dst map[string]string, key, value string) { + if value == "" { + return + } + if _, ok := dst[key]; !ok { + dst[key] = value + } +} + +func metadataValue(metadata map[string]string, key string) string { + if metadata == nil { + return "" + } + return strings.TrimSpace(metadata[key]) +} + +func cloneStringMap(src map[string]string) map[string]string { + if len(src) == 0 { + return nil + } + + dst := make(map[string]string, len(src)) + for k, v := range src { + dst[k] = v + } + return dst +} + +func firstNonEmpty(values ...string) string { + for _, value := range values { + if value != "" { + return value + } + } + return "" +} + +func normalizeKind(value string) string { + return strings.ToLower(strings.TrimSpace(value)) +} + +func isTruthy(value string) bool { + switch strings.ToLower(strings.TrimSpace(value)) { + case "1", "t", "true", "y", "yes", "on": + return true + default: + return false + } +} diff --git a/pkg/bus/types.go b/pkg/bus/types.go index 12da3f1dd..0c4cd707b 100644 --- a/pkg/bus/types.go +++ b/pkg/bus/types.go @@ -15,11 +15,39 @@ type SenderInfo struct { DisplayName string `json:"display_name,omitempty"` // display name } +// InboundContext captures the normalized, platform-agnostic facts about an +// inbound message. This is the long-term source of truth for routing and +// session allocation. Legacy top-level fields on InboundMessage remain during +// the transition and are derived from this context when missing. +type InboundContext struct { + Channel string `json:"channel"` + Account string `json:"account,omitempty"` + + ChatID string `json:"chat_id"` + ChatType string `json:"chat_type,omitempty"` // direct / group / channel + TopicID string `json:"topic_id,omitempty"` + + SpaceID string `json:"space_id,omitempty"` + SpaceType string `json:"space_type,omitempty"` // guild / team / workspace / tenant + + SenderID string `json:"sender_id"` + MessageID string `json:"message_id,omitempty"` + + Mentioned bool `json:"mentioned,omitempty"` + + ReplyToMessageID string `json:"reply_to_message_id,omitempty"` + ReplyToSenderID string `json:"reply_to_sender_id,omitempty"` + + ReplyHandles map[string]string `json:"reply_handles,omitempty"` + Raw map[string]string `json:"raw,omitempty"` +} + type InboundMessage struct { Channel string `json:"channel"` SenderID string `json:"sender_id"` Sender SenderInfo `json:"sender"` ChatID string `json:"chat_id"` + Context InboundContext `json:"context"` Content string `json:"content"` Media []string `json:"media,omitempty"` Peer Peer `json:"peer"` // routing peer diff --git a/pkg/channels/base.go b/pkg/channels/base.go index bd4ced849..fd68ebcc2 100644 --- a/pkg/channels/base.go +++ b/pkg/channels/base.go @@ -287,6 +287,7 @@ func (c *BaseChannel) HandleMessage( MediaScope: scope, Metadata: metadata, } + msg.Context = bus.ContextFromLegacyInbound(msg) // Auto-trigger typing indicator, message reaction, and placeholder before publishing. // Each capability is independent — all three may fire for the same message. From cf11ff70c3cc0ad4b8e3f08a8f362d51b4a446cd Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 13:50:24 +0800 Subject: [PATCH 003/174] refactor(channels): emit inbound context in primary adapters --- pkg/channels/base.go | 65 ++++++++++++++++++++++++------- pkg/channels/discord/discord.go | 20 +++++++++- pkg/channels/slack/slack.go | 56 ++++++++++++++++++++++---- pkg/channels/telegram/telegram.go | 29 ++++++++------ 4 files changed, 137 insertions(+), 33 deletions(-) diff --git a/pkg/channels/base.go b/pkg/channels/base.go index fd68ebcc2..8161fa12e 100644 --- a/pkg/channels/base.go +++ b/pkg/channels/base.go @@ -251,12 +251,39 @@ func (c *BaseChannel) HandleMessage( media []string, metadata map[string]string, senderOpts ...bus.SenderInfo, +) { + var sender bus.SenderInfo + if len(senderOpts) > 0 { + sender = senderOpts[0] + } + + inboundCtx := bus.ContextFromLegacyInbound(bus.InboundMessage{ + Channel: c.name, + SenderID: senderID, + Sender: sender, + ChatID: chatID, + Peer: peer, + MessageID: messageID, + Metadata: metadata, + }) + + c.HandleMessageWithContext(ctx, peer, chatID, content, media, inboundCtx, senderOpts...) +} + +func (c *BaseChannel) HandleMessageWithContext( + ctx context.Context, + peer bus.Peer, + deliveryChatID, content string, + media []string, + inboundCtx bus.InboundContext, + senderOpts ...bus.SenderInfo, ) { // Use SenderInfo-based allow check when available, else fall back to string var sender bus.SenderInfo if len(senderOpts) > 0 { sender = senderOpts[0] } + senderID := strings.TrimSpace(inboundCtx.SenderID) if sender.CanonicalID != "" || sender.PlatformID != "" { if !c.IsAllowedSender(sender) { return @@ -273,21 +300,33 @@ func (c *BaseChannel) HandleMessage( resolvedSenderID = sender.CanonicalID } - scope := BuildMediaScope(c.name, chatID, messageID) + if resolvedSenderID == "" { + resolvedSenderID = senderID + } + + inboundCtx.Channel = c.name + if inboundCtx.ChatID == "" { + inboundCtx.ChatID = deliveryChatID + } + if inboundCtx.SenderID == "" { + inboundCtx.SenderID = resolvedSenderID + } + + scope := BuildMediaScope(c.name, deliveryChatID, inboundCtx.MessageID) msg := bus.InboundMessage{ Channel: c.name, SenderID: resolvedSenderID, Sender: sender, - ChatID: chatID, + ChatID: deliveryChatID, + Context: inboundCtx, Content: content, Media: media, Peer: peer, - MessageID: messageID, + MessageID: inboundCtx.MessageID, MediaScope: scope, - Metadata: metadata, } - msg.Context = bus.ContextFromLegacyInbound(msg) + msg = bus.NormalizeInboundMessage(msg) // Auto-trigger typing indicator, message reaction, and placeholder before publishing. // Each capability is independent — all three may fire for the same message. @@ -298,14 +337,14 @@ func (c *BaseChannel) HandleMessage( if c.owner != nil && c.placeholderRecorder != nil { // Typing if tc, ok := c.owner.(TypingCapable); ok { - if stop, err := tc.StartTyping(ctx, chatID); err == nil { - c.placeholderRecorder.RecordTypingStop(c.name, chatID, stop) + if stop, err := tc.StartTyping(ctx, deliveryChatID); err == nil { + c.placeholderRecorder.RecordTypingStop(c.name, deliveryChatID, stop) } } // Reaction - if rc, ok := c.owner.(ReactionCapable); ok && messageID != "" { - if undo, err := rc.ReactToMessage(ctx, chatID, messageID); err == nil { - c.placeholderRecorder.RecordReactionUndo(c.name, chatID, undo) + if rc, ok := c.owner.(ReactionCapable); ok && msg.MessageID != "" { + if undo, err := rc.ReactToMessage(ctx, deliveryChatID, msg.MessageID); err == nil { + c.placeholderRecorder.RecordReactionUndo(c.name, deliveryChatID, undo) } } // Placeholder — independent pipeline. @@ -314,8 +353,8 @@ func (c *BaseChannel) HandleMessage( // "Thinking…" only once the voice has been processed. if !audioAnnotationRe.MatchString(content) { if pc, ok := c.owner.(PlaceholderCapable); ok { - if phID, err := pc.SendPlaceholder(ctx, chatID); err == nil && phID != "" { - c.placeholderRecorder.RecordPlaceholder(c.name, chatID, phID) + if phID, err := pc.SendPlaceholder(ctx, deliveryChatID); err == nil && phID != "" { + c.placeholderRecorder.RecordPlaceholder(c.name, deliveryChatID, phID) } } } @@ -324,7 +363,7 @@ func (c *BaseChannel) HandleMessage( if err := c.bus.PublishInbound(ctx, msg); err != nil { logger.ErrorCF("channels", "Failed to publish inbound message", map[string]any{ "channel": c.name, - "chat_id": chatID, + "chat_id": deliveryChatID, "error": err.Error(), }) } diff --git a/pkg/channels/discord/discord.go b/pkg/channels/discord/discord.go index b3070a822..0376dcdae 100644 --- a/pkg/channels/discord/discord.go +++ b/pkg/channels/discord/discord.go @@ -363,8 +363,8 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag // In guild (group) channels, apply unified group trigger filtering // DMs (GuildID is empty) always get a response + isMentioned := false if m.GuildID != "" { - isMentioned := false for _, mention := range m.Mentions { if mention.ID == c.botUserID { isMentioned = true @@ -477,8 +477,24 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag "channel_id": m.ChannelID, "is_dm": fmt.Sprintf("%t", m.GuildID == ""), } + inboundCtx := bus.InboundContext{ + Channel: c.Name(), + ChatID: m.ChannelID, + ChatType: peerKind, + SenderID: senderID, + MessageID: m.ID, + Mentioned: isMentioned, + Raw: metadata, + } + if m.GuildID != "" { + inboundCtx.SpaceID = m.GuildID + inboundCtx.SpaceType = "guild" + } + if m.MessageReference != nil { + inboundCtx.ReplyToMessageID = m.MessageReference.MessageID + } - c.HandleMessage(c.ctx, peer, m.ID, senderID, m.ChannelID, content, mediaPaths, metadata, sender) + c.HandleMessageWithContext(c.ctx, peer, m.ChannelID, content, mediaPaths, inboundCtx, sender) } // startTyping starts a continuous typing indicator loop for the given chatID. diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go index 1e4a4fef5..882cc5cb5 100644 --- a/pkg/channels/slack/slack.go +++ b/pkg/channels/slack/slack.go @@ -379,7 +379,22 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) { "has_thread": threadTS != "", }) - c.HandleMessage(c.ctx, peer, messageTS, senderID, chatID, content, mediaPaths, metadata, sender) + inboundCtx := bus.InboundContext{ + Channel: c.Name(), + Account: c.teamID, + ChatID: channelID, + ChatType: peerKind, + SenderID: senderID, + MessageID: messageTS, + SpaceID: c.teamID, + SpaceType: "workspace", + Raw: metadata, + } + if threadTS != "" { + inboundCtx.TopicID = threadTS + } + + c.HandleMessageWithContext(c.ctx, peer, chatID, content, mediaPaths, inboundCtx, sender) } func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) { @@ -443,8 +458,21 @@ func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) { "is_mention": "true", "team_id": c.teamID, } + inboundCtx := bus.InboundContext{ + Channel: c.Name(), + Account: c.teamID, + ChatID: channelID, + ChatType: mentionPeerKind, + TopicID: threadTS, + SenderID: senderID, + MessageID: messageTS, + SpaceID: c.teamID, + SpaceType: "workspace", + Mentioned: true, + Raw: metadata, + } - c.HandleMessage(c.ctx, mentionPeer, messageTS, senderID, chatID, content, nil, metadata, mentionSender) + c.HandleMessageWithContext(c.ctx, mentionPeer, chatID, content, nil, inboundCtx, mentionSender) } func (c *SlackChannel) handleSlashCommand(event socketmode.Event) { @@ -491,16 +519,30 @@ func (c *SlackChannel) handleSlashCommand(event socketmode.Event) { "command": cmd.Command, "text": utils.Truncate(content, 50), }) + peerKind := "channel" + peerID := channelID + if strings.HasPrefix(channelID, "D") { + peerKind = "direct" + peerID = senderID + } + inboundCtx := bus.InboundContext{ + Channel: c.Name(), + Account: c.teamID, + ChatID: channelID, + ChatType: peerKind, + SenderID: senderID, + SpaceID: c.teamID, + SpaceType: "workspace", + Raw: metadata, + } - c.HandleMessage( + c.HandleMessageWithContext( c.ctx, - bus.Peer{Kind: "channel", ID: channelID}, - "", - senderID, + bus.Peer{Kind: peerKind, ID: peerID}, chatID, content, nil, - metadata, + inboundCtx, cmdSender, ) } diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go index 831eb43cc..e1532bcf9 100644 --- a/pkg/channels/telegram/telegram.go +++ b/pkg/channels/telegram/telegram.go @@ -660,8 +660,9 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes } // In group chats, apply unified group trigger filtering + isMentioned := false if message.Chat.Type != "private" { - isMentioned := c.isBotMentioned(message) + isMentioned = c.isBotMentioned(message) if isMentioned { content = c.stripBotMention(content) } @@ -722,24 +723,30 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes "first_name": user.FirstName, "is_group": fmt.Sprintf("%t", message.Chat.Type != "private"), } - if message.ReplyToMessage != nil { - metadata["reply_to_message_id"] = fmt.Sprintf("%d", message.ReplyToMessage.MessageID) - } - // Set parent_peer metadata for per-topic agent binding. + inboundCtx := bus.InboundContext{ + Channel: c.Name(), + ChatID: fmt.Sprintf("%d", chatID), + ChatType: peerKind, + SenderID: platformID, + MessageID: messageID, + Mentioned: isMentioned, + Raw: metadata, + } if message.Chat.IsForum && threadID != 0 { - metadata["parent_peer_kind"] = "topic" - metadata["parent_peer_id"] = fmt.Sprintf("%d", threadID) + inboundCtx.TopicID = fmt.Sprintf("%d", threadID) + } + if message.ReplyToMessage != nil { + inboundCtx.ReplyToMessageID = fmt.Sprintf("%d", message.ReplyToMessage.MessageID) } - c.HandleMessage(c.ctx, + c.HandleMessageWithContext( + c.ctx, peer, - messageID, - platformID, compositeChatID, content, mediaPaths, - metadata, + inboundCtx, sender, ) return nil From 963ed07d69b8aa706c3bf97bf96f781a34b20a27 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 13:58:31 +0800 Subject: [PATCH 004/174] refactor(channels): emit inbound context in secondary adapters --- pkg/channels/line/line.go | 23 +++++++++++++++++++++-- pkg/channels/onebot/onebot.go | 19 ++++++++++++++++++- pkg/channels/qq/qq.go | 33 +++++++++++++++++++++++++-------- pkg/channels/wecom/wecom.go | 15 ++++++++++++++- 4 files changed, 78 insertions(+), 12 deletions(-) diff --git a/pkg/channels/line/line.go b/pkg/channels/line/line.go index e29896389..269f14997 100644 --- a/pkg/channels/line/line.go +++ b/pkg/channels/line/line.go @@ -350,8 +350,9 @@ func (c *LINEChannel) processEvent(event lineEvent) { } // In group chats, apply unified group trigger filtering + isMentioned := false if isGroup { - isMentioned := c.isBotMentioned(msg) + isMentioned = c.isBotMentioned(msg) respond, cleaned := c.ShouldRespondInGroup(isMentioned, content) if !respond { logger.DebugCF("line", "Ignoring group message by group trigger", map[string]any{ @@ -392,7 +393,25 @@ func (c *LINEChannel) processEvent(event lineEvent) { return } - c.HandleMessage(c.ctx, peer, msg.ID, senderID, chatID, content, mediaPaths, metadata, sender) + inboundCtx := bus.InboundContext{ + Channel: c.Name(), + ChatID: chatID, + ChatType: peer.Kind, + SenderID: senderID, + MessageID: msg.ID, + Mentioned: isMentioned, + Raw: metadata, + } + if event.ReplyToken != "" { + inboundCtx.ReplyHandles = map[string]string{ + "reply_token": event.ReplyToken, + } + if msg.QuoteToken != "" { + inboundCtx.ReplyHandles["quote_token"] = msg.QuoteToken + } + } + + c.HandleMessageWithContext(c.ctx, peer, chatID, content, mediaPaths, inboundCtx, sender) } // isBotMentioned checks if the bot is mentioned in the message. diff --git a/pkg/channels/onebot/onebot.go b/pkg/channels/onebot/onebot.go index a9b95c20f..e5651b046 100644 --- a/pkg/channels/onebot/onebot.go +++ b/pkg/channels/onebot/onebot.go @@ -991,6 +991,8 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) { senderID := strconv.FormatInt(userID, 10) var chatID string + var contextChatID string + var contextChatType string var peer bus.Peer @@ -1003,11 +1005,15 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) { switch raw.MessageType { case "private": chatID = "private:" + senderID + contextChatID = senderID + contextChatType = "direct" peer = bus.Peer{Kind: "direct", ID: senderID} case "group": groupIDStr := strconv.FormatInt(groupID, 10) chatID = "group:" + groupIDStr + contextChatID = groupIDStr + contextChatType = "group" peer = bus.Peer{Kind: "group", ID: groupIDStr} metadata["group_id"] = groupIDStr @@ -1072,7 +1078,18 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) { return } - c.HandleMessage(c.ctx, peer, messageID, senderID, chatID, content, parsed.Media, metadata, senderInfo) + inboundCtx := bus.InboundContext{ + Channel: c.Name(), + ChatID: contextChatID, + ChatType: contextChatType, + SenderID: senderID, + MessageID: messageID, + Mentioned: isBotMentioned, + ReplyToMessageID: parsed.ReplyTo, + Raw: metadata, + } + + c.HandleMessageWithContext(c.ctx, peer, chatID, content, parsed.Media, inboundCtx, senderInfo) } func (c *OneBotChannel) isDuplicate(messageID string) bool { diff --git a/pkg/channels/qq/qq.go b/pkg/channels/qq/qq.go index 3a8cf9652..ba0045da6 100644 --- a/pkg/channels/qq/qq.go +++ b/pkg/channels/qq/qq.go @@ -647,15 +647,23 @@ func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler { metadata := map[string]string{ "account_id": senderID, } + inboundCtx := bus.InboundContext{ + Channel: c.Name(), + Account: c.config.AppID, + ChatID: senderID, + ChatType: "direct", + SenderID: senderID, + MessageID: data.ID, + Raw: metadata, + } - c.HandleMessage(c.ctx, + c.HandleMessageWithContext( + c.ctx, bus.Peer{Kind: "direct", ID: senderID}, - data.ID, - senderID, senderID, content, mediaPaths, - metadata, + inboundCtx, sender, ) @@ -725,15 +733,24 @@ func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler { "account_id": senderID, "group_id": data.GroupID, } + inboundCtx := bus.InboundContext{ + Channel: c.Name(), + Account: c.config.AppID, + ChatID: data.GroupID, + ChatType: "group", + SenderID: senderID, + MessageID: data.ID, + Mentioned: true, + Raw: metadata, + } - c.HandleMessage(c.ctx, + c.HandleMessageWithContext( + c.ctx, bus.Peer{Kind: "group", ID: data.GroupID}, - data.ID, - senderID, data.GroupID, content, mediaPaths, - metadata, + inboundCtx, sender, ) diff --git a/pkg/channels/wecom/wecom.go b/pkg/channels/wecom/wecom.go index 9689d5171..65b9b4ca4 100644 --- a/pkg/channels/wecom/wecom.go +++ b/pkg/channels/wecom/wecom.go @@ -583,7 +583,20 @@ func (c *WeComChannel) dispatchIncoming(reqID string, msg wecomIncomingMessage) metadata["quote_text"] = quoteText } - c.HandleMessage(c.ctx, peer, msg.MsgID, senderID, actualChatID, content, mediaRefs, metadata, sender) + inboundCtx := bus.InboundContext{ + Channel: c.Name(), + Account: strings.TrimSpace(msg.AIBotID), + ChatID: actualChatID, + ChatType: peerKind, + SenderID: senderID, + MessageID: msg.MsgID, + ReplyHandles: map[string]string{ + "req_id": reqID, + }, + Raw: metadata, + } + + c.HandleMessageWithContext(c.ctx, peer, actualChatID, content, mediaRefs, inboundCtx, sender) return nil } From 2095ec8700343935b2a296102d4f77fad38eb07a Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 14:08:44 +0800 Subject: [PATCH 005/174] refactor(agent): route using inbound context --- pkg/agent/loop.go | 80 +++++++++++++++++++++++++++++++------ pkg/agent/loop_test.go | 89 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 156 insertions(+), 13 deletions(-) diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go index 84b783985..78b91068a 100644 --- a/pkg/agent/loop.go +++ b/pkg/agent/loop.go @@ -1372,13 +1372,18 @@ func (al *AgentLoop) processMessage(ctx context.Context, msg bus.InboundMessage) func (al *AgentLoop) resolveMessageRoute(msg bus.InboundMessage) (routing.ResolvedRoute, *AgentInstance, error) { registry := al.GetRegistry() + inboundCtx := normalizedInboundContext(msg) + channel := strings.TrimSpace(inboundCtx.Channel) + if channel == "" { + channel = msg.Channel + } route := registry.ResolveRoute(routing.RouteInput{ - Channel: msg.Channel, - AccountID: inboundMetadata(msg, metadataKeyAccountID), + Channel: channel, + AccountID: routeAccountID(msg), Peer: extractPeer(msg), ParentPeer: extractParentPeer(msg), - GuildID: inboundMetadata(msg, metadataKeyGuildID), - TeamID: inboundMetadata(msg, metadataKeyTeamID), + GuildID: routeGuildID(msg), + TeamID: routeTeamID(msg), }) agent, ok := registry.GetAgent(route.AgentID) @@ -1392,6 +1397,10 @@ func (al *AgentLoop) resolveMessageRoute(msg bus.InboundMessage) (routing.Resolv return route, agent, nil } +func normalizedInboundContext(msg bus.InboundMessage) bus.InboundContext { + return bus.NormalizeInboundMessage(msg).Context +} + func resolveScopeKey(route routing.ResolvedRoute, msgSessionKey string) string { if msgSessionKey != "" && strings.HasPrefix(msgSessionKey, sessionKeyAgentPrefix) { return msgSessionKey @@ -3553,18 +3562,32 @@ func mapCommandError(result commands.ExecuteResult) string { // extractPeer extracts the routing peer from the inbound message's structured Peer field. func extractPeer(msg bus.InboundMessage) *routing.RoutePeer { - if msg.Peer.Kind == "" { + if msg.Peer.Kind != "" { + peerID := msg.Peer.ID + if peerID == "" { + if msg.Peer.Kind == "direct" { + peerID = msg.SenderID + } else { + peerID = msg.ChatID + } + } + return &routing.RoutePeer{Kind: msg.Peer.Kind, ID: peerID} + } + + inboundCtx := normalizedInboundContext(msg) + peerKind := strings.TrimSpace(inboundCtx.ChatType) + if peerKind == "" { return nil } - peerID := msg.Peer.ID - if peerID == "" { - if msg.Peer.Kind == "direct" { - peerID = msg.SenderID - } else { - peerID = msg.ChatID - } + + peerID := strings.TrimSpace(inboundCtx.ChatID) + if peerKind == "direct" && peerID == "" { + peerID = strings.TrimSpace(inboundCtx.SenderID) } - return &routing.RoutePeer{Kind: msg.Peer.Kind, ID: peerID} + if peerID == "" { + return nil + } + return &routing.RoutePeer{Kind: peerKind, ID: peerID} } func inboundMetadata(msg bus.InboundMessage, key string) string { @@ -3576,6 +3599,11 @@ func inboundMetadata(msg bus.InboundMessage, key string) string { // extractParentPeer extracts the parent peer (reply-to) from inbound message metadata. func extractParentPeer(msg bus.InboundMessage) *routing.RoutePeer { + inboundCtx := normalizedInboundContext(msg) + if topicID := strings.TrimSpace(inboundCtx.TopicID); topicID != "" { + return &routing.RoutePeer{Kind: "topic", ID: topicID} + } + parentKind := inboundMetadata(msg, metadataKeyParentPeerKind) parentID := inboundMetadata(msg, metadataKeyParentPeerID) if parentKind == "" || parentID == "" { @@ -3584,6 +3612,32 @@ func extractParentPeer(msg bus.InboundMessage) *routing.RoutePeer { return &routing.RoutePeer{Kind: parentKind, ID: parentID} } +func routeAccountID(msg bus.InboundMessage) string { + if accountID := strings.TrimSpace(normalizedInboundContext(msg).Account); accountID != "" { + return accountID + } + return inboundMetadata(msg, metadataKeyAccountID) +} + +func routeGuildID(msg bus.InboundMessage) string { + inboundCtx := normalizedInboundContext(msg) + if strings.EqualFold(strings.TrimSpace(inboundCtx.SpaceType), "guild") { + return strings.TrimSpace(inboundCtx.SpaceID) + } + return inboundMetadata(msg, metadataKeyGuildID) +} + +func routeTeamID(msg bus.InboundMessage) string { + inboundCtx := normalizedInboundContext(msg) + switch strings.ToLower(strings.TrimSpace(inboundCtx.SpaceType)) { + case "team", "workspace": + if spaceID := strings.TrimSpace(inboundCtx.SpaceID); spaceID != "" { + return spaceID + } + } + return inboundMetadata(msg, metadataKeyTeamID) +} + // isNativeSearchProvider reports whether the given LLM provider implements // NativeSearchCapable and returns true for SupportsNativeSearch. func isNativeSearchProvider(p providers.LLMProvider) bool { diff --git a/pkg/agent/loop_test.go b/pkg/agent/loop_test.go index 9513d8aca..54235b23a 100644 --- a/pkg/agent/loop_test.go +++ b/pkg/agent/loop_test.go @@ -734,6 +734,95 @@ func TestProcessMessage_HandledToolProcessesQueuedSteeringBeforeReturning(t *tes } } +func TestExtractPeer_UsesInboundContextWhenLegacyPeerMissing(t *testing.T) { + msg := bus.InboundMessage{ + Context: bus.InboundContext{ + Channel: "slack", + ChatID: "C001", + ChatType: "channel", + SenderID: "U001", + }, + } + + peer := extractPeer(msg) + if peer == nil { + t.Fatal("expected peer from inbound context") + } + if peer.Kind != "channel" || peer.ID != "C001" { + t.Fatalf("peer = %+v, want channel/C001", peer) + } +} + +func TestExtractParentPeer_UsesInboundContextTopicID(t *testing.T) { + msg := bus.InboundMessage{ + Context: bus.InboundContext{ + TopicID: "thread-42", + }, + } + + parentPeer := extractParentPeer(msg) + if parentPeer == nil { + t.Fatal("expected parent peer from topic context") + } + if parentPeer.Kind != "topic" || parentPeer.ID != "thread-42" { + t.Fatalf("parent peer = %+v, want topic/thread-42", parentPeer) + } +} + +func TestResolveMessageRoute_UsesInboundContextAccountAndSpace(t *testing.T) { + tmpDir := t.TempDir() + cfg := &config.Config{ + Agents: config.AgentsConfig{ + Defaults: config.AgentDefaults{ + Workspace: tmpDir, + ModelName: "test-model", + }, + List: []config.AgentConfig{ + {ID: "main", Default: true}, + {ID: "work"}, + }, + }, + Bindings: []config.AgentBinding{ + { + AgentID: "work", + Match: config.BindingMatch{ + Channel: "slack", + AccountID: "*", + TeamID: "T001", + }, + }, + }, + Session: config.SessionConfig{ + DMScope: "per-peer", + }, + } + + msgBus := bus.NewMessageBus() + al := NewAgentLoop(cfg, msgBus, &simpleMockProvider{response: "ok"}) + + route, _, err := al.resolveMessageRoute(bus.InboundMessage{ + Context: bus.InboundContext{ + Channel: "slack", + Account: "workspace-a", + ChatID: "C123", + ChatType: "channel", + SenderID: "U123", + SpaceID: "T001", + SpaceType: "workspace", + }, + Content: "hello", + }) + if err != nil { + t.Fatalf("resolveMessageRoute() error = %v", err) + } + if route.AgentID != "work" { + t.Fatalf("AgentID = %q, want work", route.AgentID) + } + if route.MatchedBy != "binding.team" { + t.Fatalf("MatchedBy = %q, want binding.team", route.MatchedBy) + } +} + func TestProcessMessage_MediaArtifactCanBeForwardedBySendFile(t *testing.T) { tmpDir := t.TempDir() cfg := config.DefaultConfig() From fcab3a1b7c815d746e9c1edbf2d6d59e32fc89f5 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 14:26:12 +0800 Subject: [PATCH 006/174] refactor(routing): move session allocation out of router --- pkg/agent/loop.go | 41 ++++++++++++++------- pkg/agent/loop_test.go | 19 ++++++++-- pkg/routing/route.go | 68 ++++++++++++++++++++++------------- pkg/routing/route_test.go | 6 ++++ pkg/session/allocator.go | 43 ++++++++++++++++++++++ pkg/session/allocator_test.go | 51 ++++++++++++++++++++++++++ 6 files changed, 188 insertions(+), 40 deletions(-) create mode 100644 pkg/session/allocator.go create mode 100644 pkg/session/allocator_test.go diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go index 78b91068a..39a2e1539 100644 --- a/pkg/agent/loop.go +++ b/pkg/agent/loop.go @@ -27,6 +27,7 @@ import ( "github.com/sipeed/picoclaw/pkg/media" "github.com/sipeed/picoclaw/pkg/providers" "github.com/sipeed/picoclaw/pkg/routing" + "github.com/sipeed/picoclaw/pkg/session" "github.com/sipeed/picoclaw/pkg/skills" "github.com/sipeed/picoclaw/pkg/state" "github.com/sipeed/picoclaw/pkg/tools" @@ -672,9 +673,10 @@ func (al *AgentLoop) buildContinuationTarget(msg bus.InboundMessage) (*continuat if err != nil { return nil, err } + allocation := al.allocateRouteSession(route, msg) return &continuationTarget{ - SessionKey: resolveScopeKey(route, msg.SessionKey), + SessionKey: resolveScopeKey(allocation.SessionKey, msg.SessionKey), Channel: msg.Channel, ChatID: msg.ChatID, }, nil @@ -1323,18 +1325,22 @@ func (al *AgentLoop) processMessage(ctx context.Context, msg bus.InboundMessage) } } - // Resolve session key from route, while preserving explicit agent-scoped keys. - scopeKey := resolveScopeKey(route, msg.SessionKey) + allocation := al.allocateRouteSession(route, msg) + + // Resolve session key from the route allocation, while preserving explicit + // agent-scoped keys supplied by the caller. + scopeKey := resolveScopeKey(allocation.SessionKey, msg.SessionKey) sessionKey := scopeKey logger.InfoCF("agent", "Routed message", map[string]any{ - "agent_id": agent.ID, - "scope_key": scopeKey, - "session_key": sessionKey, - "matched_by": route.MatchedBy, - "route_agent": route.AgentID, - "route_channel": route.Channel, + "agent_id": agent.ID, + "scope_key": scopeKey, + "session_key": sessionKey, + "matched_by": route.MatchedBy, + "route_agent": route.AgentID, + "route_channel": route.Channel, + "route_main_session": allocation.MainSessionKey, }) opts := processOptions{ @@ -1401,11 +1407,21 @@ func normalizedInboundContext(msg bus.InboundMessage) bus.InboundContext { return bus.NormalizeInboundMessage(msg).Context } -func resolveScopeKey(route routing.ResolvedRoute, msgSessionKey string) string { +func resolveScopeKey(routeSessionKey, msgSessionKey string) string { if msgSessionKey != "" && strings.HasPrefix(msgSessionKey, sessionKeyAgentPrefix) { return msgSessionKey } - return route.SessionKey + return routeSessionKey +} + +func (al *AgentLoop) allocateRouteSession(route routing.ResolvedRoute, msg bus.InboundMessage) session.Allocation { + return session.AllocateRouteSession(session.AllocationInput{ + AgentID: route.AgentID, + Channel: route.Channel, + AccountID: route.AccountID, + Peer: extractPeer(msg), + SessionPolicy: route.SessionPolicy, + }) } func (al *AgentLoop) resolveSteeringTarget(msg bus.InboundMessage) (string, string, bool) { @@ -1417,8 +1433,9 @@ func (al *AgentLoop) resolveSteeringTarget(msg bus.InboundMessage) (string, stri if err != nil || agent == nil { return "", "", false } + allocation := al.allocateRouteSession(route, msg) - return resolveScopeKey(route, msg.SessionKey), agent.ID, true + return resolveScopeKey(allocation.SessionKey, msg.SessionKey), agent.ID, true } func (al *AgentLoop) requeueInboundMessage(msg bus.InboundMessage) error { diff --git a/pkg/agent/loop_test.go b/pkg/agent/loop_test.go index 54235b23a..1f99a5085 100644 --- a/pkg/agent/loop_test.go +++ b/pkg/agent/loop_test.go @@ -670,7 +670,12 @@ func TestProcessMessage_MediaToolHandledSkipsFollowUpLLMAndFinalText(t *testing. if err != nil { t.Fatalf("resolveMessageRoute() error = %v", err) } - sessionKey := resolveScopeKey(route, "") + sessionKey := resolveScopeKey(al.allocateRouteSession(route, bus.InboundMessage{ + Channel: "telegram", + ChatID: "chat1", + SenderID: "user1", + Content: "take a screenshot of the screen and send it to me", + }).SessionKey, "") history := defaultAgent.Sessions.GetHistory(sessionKey) if len(history) == 0 { t.Fatal("expected session history to be saved") @@ -1492,7 +1497,7 @@ func TestProcessMessage_UsesRouteSessionKey(t *testing.T) { Channel: msg.Channel, Peer: extractPeer(msg), }) - sessionKey := route.SessionKey + sessionKey := al.allocateRouteSession(route, msg).SessionKey defaultAgent := al.registry.GetDefaultAgent() if defaultAgent == nil { @@ -2195,7 +2200,15 @@ func TestAgentLoop_ToolLimitUsesDedicatedFallback(t *testing.T) { ID: "cron", }, }) - history := defaultAgent.Sessions.GetHistory(route.SessionKey) + history := defaultAgent.Sessions.GetHistory(al.allocateRouteSession(route, bus.InboundMessage{ + Channel: "test", + SenderID: "cron", + ChatID: "chat1", + Peer: bus.Peer{ + Kind: "direct", + ID: "cron", + }, + }).SessionKey) if len(history) != 4 { t.Fatalf("history len = %d, want 4", len(history)) } diff --git a/pkg/routing/route.go b/pkg/routing/route.go index 9eb060c53..494aefabb 100644 --- a/pkg/routing/route.go +++ b/pkg/routing/route.go @@ -16,14 +16,21 @@ type RouteInput struct { TeamID string } +// SessionPolicy describes how a routed message should be mapped to a session. +// The current implementation preserves the legacy dm_scope and identity_link +// semantics while moving session-key construction out of the router. +type SessionPolicy struct { + DMScope DMScope + IdentityLinks map[string][]string +} + // ResolvedRoute is the result of agent routing. type ResolvedRoute struct { - AgentID string - Channel string - AccountID string - SessionKey string - MainSessionKey string - MatchedBy string // "binding.peer", "binding.peer.parent", "binding.guild", "binding.team", "binding.account", "binding.channel", "default" + AgentID string + Channel string + AccountID string + SessionPolicy SessionPolicy + MatchedBy string // "binding.peer", "binding.peer.parent", "binding.guild", "binding.team", "binding.account", "binding.channel", "default" } // RouteResolver determines which agent handles a message based on config bindings. @@ -36,7 +43,8 @@ func NewRouteResolver(cfg *config.Config) *RouteResolver { return &RouteResolver{cfg: cfg} } -// ResolveRoute determines which agent handles the message and constructs session keys. +// ResolveRoute determines which agent handles the message and returns the +// session policy that should be used to allocate session state. // Implements the 7-level priority cascade: // peer > parent_peer > guild > team > account > channel_wildcard > default func (r *RouteResolver) ResolveRoute(input RouteInput) ResolvedRoute { @@ -44,32 +52,18 @@ func (r *RouteResolver) ResolveRoute(input RouteInput) ResolvedRoute { accountID := NormalizeAccountID(input.AccountID) peer := input.Peer - dmScope := DMScope(r.cfg.Session.DMScope) - if dmScope == "" { - dmScope = DMScopeMain - } - identityLinks := r.cfg.Session.IdentityLinks + sessionPolicy := r.sessionPolicy() bindings := r.filterBindings(channel, accountID) choose := func(agentID string, matchedBy string) ResolvedRoute { resolvedAgentID := r.pickAgentID(agentID) - sessionKey := strings.ToLower(BuildAgentPeerSessionKey(SessionKeyParams{ + return ResolvedRoute{ AgentID: resolvedAgentID, Channel: channel, AccountID: accountID, - Peer: peer, - DMScope: dmScope, - IdentityLinks: identityLinks, - })) - mainSessionKey := strings.ToLower(BuildAgentMainSessionKey(resolvedAgentID)) - return ResolvedRoute{ - AgentID: resolvedAgentID, - Channel: channel, - AccountID: accountID, - SessionKey: sessionKey, - MainSessionKey: mainSessionKey, - MatchedBy: matchedBy, + SessionPolicy: sessionPolicy, + MatchedBy: matchedBy, } } @@ -250,3 +244,27 @@ func (r *RouteResolver) resolveDefaultAgentID() string { } return DefaultAgentID } + +func (r *RouteResolver) sessionPolicy() SessionPolicy { + dmScope := DMScope(r.cfg.Session.DMScope) + if dmScope == "" { + dmScope = DMScopeMain + } + return SessionPolicy{ + DMScope: dmScope, + IdentityLinks: cloneIdentityLinks(r.cfg.Session.IdentityLinks), + } +} + +func cloneIdentityLinks(src map[string][]string) map[string][]string { + if len(src) == 0 { + return nil + } + cloned := make(map[string][]string, len(src)) + for canonical, ids := range src { + dup := make([]string, len(ids)) + copy(dup, ids) + cloned[canonical] = dup + } + return cloned +} diff --git a/pkg/routing/route_test.go b/pkg/routing/route_test.go index fdfc899f9..ab1a7a4e2 100644 --- a/pkg/routing/route_test.go +++ b/pkg/routing/route_test.go @@ -37,6 +37,12 @@ func TestResolveRoute_DefaultAgent_NoBindings(t *testing.T) { if route.MatchedBy != "default" { t.Errorf("MatchedBy = %q, want 'default'", route.MatchedBy) } + if route.SessionPolicy.DMScope != DMScopePerPeer { + t.Errorf("SessionPolicy.DMScope = %q, want %q", route.SessionPolicy.DMScope, DMScopePerPeer) + } + if route.SessionPolicy.IdentityLinks != nil { + t.Errorf("SessionPolicy.IdentityLinks = %v, want nil", route.SessionPolicy.IdentityLinks) + } } func TestResolveRoute_PeerBinding(t *testing.T) { diff --git a/pkg/session/allocator.go b/pkg/session/allocator.go new file mode 100644 index 000000000..675e577f8 --- /dev/null +++ b/pkg/session/allocator.go @@ -0,0 +1,43 @@ +package session + +import ( + "strings" + + "github.com/sipeed/picoclaw/pkg/routing" +) + +// Allocation contains the concrete session keys selected for a routed turn. +// The current implementation intentionally preserves the legacy session-key +// layout while moving key construction out of the router. +type Allocation struct { + SessionKey string + MainSessionKey string +} + +// AllocationInput contains the routing result and peer context needed to +// derive the session keys for a turn. +type AllocationInput struct { + AgentID string + Channel string + AccountID string + Peer *routing.RoutePeer + SessionPolicy routing.SessionPolicy +} + +// AllocateRouteSession maps a route decision onto the current legacy +// agent-scoped session-key format. +func AllocateRouteSession(input AllocationInput) Allocation { + sessionKey := strings.ToLower(routing.BuildAgentPeerSessionKey(routing.SessionKeyParams{ + AgentID: input.AgentID, + Channel: input.Channel, + AccountID: input.AccountID, + Peer: input.Peer, + DMScope: input.SessionPolicy.DMScope, + IdentityLinks: input.SessionPolicy.IdentityLinks, + })) + mainSessionKey := strings.ToLower(routing.BuildAgentMainSessionKey(input.AgentID)) + return Allocation{ + SessionKey: sessionKey, + MainSessionKey: mainSessionKey, + } +} diff --git a/pkg/session/allocator_test.go b/pkg/session/allocator_test.go new file mode 100644 index 000000000..a6e84e09d --- /dev/null +++ b/pkg/session/allocator_test.go @@ -0,0 +1,51 @@ +package session + +import ( + "testing" + + "github.com/sipeed/picoclaw/pkg/routing" +) + +func TestAllocateRouteSession_PerPeerDM(t *testing.T) { + allocation := AllocateRouteSession(AllocationInput{ + AgentID: "main", + Channel: "telegram", + AccountID: "default", + Peer: &routing.RoutePeer{ + Kind: "direct", + ID: "User123", + }, + SessionPolicy: routing.SessionPolicy{ + DMScope: routing.DMScopePerPeer, + }, + }) + + if allocation.SessionKey != "agent:main:direct:user123" { + t.Fatalf("SessionKey = %q, want %q", allocation.SessionKey, "agent:main:direct:user123") + } + if allocation.MainSessionKey != "agent:main:main" { + t.Fatalf("MainSessionKey = %q, want %q", allocation.MainSessionKey, "agent:main:main") + } +} + +func TestAllocateRouteSession_GroupPeer(t *testing.T) { + allocation := AllocateRouteSession(AllocationInput{ + AgentID: "main", + Channel: "slack", + AccountID: "workspace-a", + Peer: &routing.RoutePeer{ + Kind: "channel", + ID: "C001", + }, + SessionPolicy: routing.SessionPolicy{ + DMScope: routing.DMScopePerAccountChannelPeer, + }, + }) + + if allocation.SessionKey != "agent:main:slack:channel:c001" { + t.Fatalf("SessionKey = %q, want %q", allocation.SessionKey, "agent:main:slack:channel:c001") + } + if allocation.MainSessionKey != "agent:main:main" { + t.Fatalf("MainSessionKey = %q, want %q", allocation.MainSessionKey, "agent:main:main") + } +} From 79de00f7f3de9e12b4462de14e4da7acf84356ad Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 14:37:43 +0800 Subject: [PATCH 007/174] refactor(agent): carry inbound context through events and hooks --- pkg/agent/eventbus_test.go | 14 +++++++++- pkg/agent/events.go | 1 + pkg/agent/hooks.go | 5 ++++ pkg/agent/hooks_test.go | 21 ++++++++++++++- pkg/agent/loop.go | 12 ++++++--- pkg/agent/subturn.go | 3 ++- pkg/agent/turn.go | 3 +++ pkg/agent/turn_context.go | 53 ++++++++++++++++++++++++++++++++++++++ 8 files changed, 106 insertions(+), 6 deletions(-) create mode 100644 pkg/agent/turn_context.go diff --git a/pkg/agent/eventbus_test.go b/pkg/agent/eventbus_test.go index 19a1ea9eb..8706a2c4e 100644 --- a/pkg/agent/eventbus_test.go +++ b/pkg/agent/eventbus_test.go @@ -136,6 +136,12 @@ func TestAgentLoop_EmitsMinimalTurnEvents(t *testing.T) { DefaultResponse: defaultResponse, EnableSummary: false, SendResponse: false, + InboundContext: &bus.InboundContext{ + Channel: "cli", + ChatID: "direct", + ChatType: "direct", + SenderID: "tester", + }, }) if err != nil { t.Fatalf("runAgentLoop failed: %v", err) @@ -176,6 +182,12 @@ func TestAgentLoop_EmitsMinimalTurnEvents(t *testing.T) { if evt.Meta.SessionKey != "session-1" { t.Fatalf("event %d has session key %q, want session-1", i, evt.Meta.SessionKey) } + if evt.Meta.Context == nil || evt.Meta.Context.Inbound == nil { + t.Fatalf("event %d missing inbound turn context", i) + } + if evt.Meta.Context.Inbound.Channel != "cli" || evt.Meta.Context.Inbound.SenderID != "tester" { + t.Fatalf("event %d inbound context = %+v", i, evt.Meta.Context.Inbound) + } } startPayload, ok := events[0].Payload.(TurnStartPayload) @@ -472,7 +484,7 @@ func TestAgentLoop_EmitsSessionSummarizeEvent(t *testing.T) { sub := al.SubscribeEvents(16) defer al.UnsubscribeEvents(sub.ID) - turnScope := al.newTurnEventScope(defaultAgent.ID, "session-1") + turnScope := al.newTurnEventScope(defaultAgent.ID, "session-1", nil) al.summarizeSession(defaultAgent, "session-1", turnScope) events := collectEventStream(sub.C) diff --git a/pkg/agent/events.go b/pkg/agent/events.go index f4562b360..fa006b9a5 100644 --- a/pkg/agent/events.go +++ b/pkg/agent/events.go @@ -98,6 +98,7 @@ type EventMeta struct { Iteration int TracePath string Source string + Context *TurnContext `json:"context,omitempty"` } // TurnEndStatus describes the terminal state of a turn. diff --git a/pkg/agent/hooks.go b/pkg/agent/hooks.go index c1ef58ffd..7a5f8c59b 100644 --- a/pkg/agent/hooks.go +++ b/pkg/agent/hooks.go @@ -103,6 +103,7 @@ func (r *LLMHookRequest) Clone() *LLMHookRequest { return nil } cloned := *r + cloned.Meta = cloneEventMeta(r.Meta) cloned.Messages = cloneProviderMessages(r.Messages) cloned.Tools = cloneToolDefinitions(r.Tools) cloned.Options = cloneStringAnyMap(r.Options) @@ -122,6 +123,7 @@ func (r *LLMHookResponse) Clone() *LLMHookResponse { return nil } cloned := *r + cloned.Meta = cloneEventMeta(r.Meta) cloned.Response = cloneLLMResponse(r.Response) return &cloned } @@ -139,6 +141,7 @@ func (r *ToolCallHookRequest) Clone() *ToolCallHookRequest { return nil } cloned := *r + cloned.Meta = cloneEventMeta(r.Meta) cloned.Arguments = cloneStringAnyMap(r.Arguments) return &cloned } @@ -156,6 +159,7 @@ func (r *ToolApprovalRequest) Clone() *ToolApprovalRequest { return nil } cloned := *r + cloned.Meta = cloneEventMeta(r.Meta) cloned.Arguments = cloneStringAnyMap(r.Arguments) return &cloned } @@ -175,6 +179,7 @@ func (r *ToolResultHookResponse) Clone() *ToolResultHookResponse { return nil } cloned := *r + cloned.Meta = cloneEventMeta(r.Meta) cloned.Arguments = cloneStringAnyMap(r.Arguments) cloned.Result = cloneToolResult(r.Result) return &cloned diff --git a/pkg/agent/hooks_test.go b/pkg/agent/hooks_test.go index 49e1b1784..1851090b8 100644 --- a/pkg/agent/hooks_test.go +++ b/pkg/agent/hooks_test.go @@ -106,7 +106,8 @@ func (p *llmHookTestProvider) GetDefaultModel() string { } type llmObserverHook struct { - eventCh chan Event + eventCh chan Event + lastInbound *bus.InboundContext } func (h *llmObserverHook) OnEvent(ctx context.Context, evt Event) error { @@ -123,6 +124,9 @@ func (h *llmObserverHook) BeforeLLM( ctx context.Context, req *LLMHookRequest, ) (*LLMHookRequest, HookDecision, error) { + if req.Meta.Context != nil { + h.lastInbound = cloneInboundContext(req.Meta.Context.Inbound) + } next := req.Clone() next.Model = "hook-model" return next, HookDecision{Action: HookActionModify}, nil @@ -155,6 +159,12 @@ func TestAgentLoop_Hooks_ObserverAndLLMInterceptor(t *testing.T) { DefaultResponse: defaultResponse, EnableSummary: false, SendResponse: false, + InboundContext: &bus.InboundContext{ + Channel: "cli", + ChatID: "direct", + ChatType: "direct", + SenderID: "hook-user", + }, }) if err != nil { t.Fatalf("runAgentLoop failed: %v", err) @@ -169,12 +179,21 @@ func TestAgentLoop_Hooks_ObserverAndLLMInterceptor(t *testing.T) { if lastModel != "hook-model" { t.Fatalf("expected model hook-model, got %q", lastModel) } + if hook.lastInbound == nil { + t.Fatal("expected hook to receive inbound context") + } + if hook.lastInbound.Channel != "cli" || hook.lastInbound.SenderID != "hook-user" { + t.Fatalf("hook inbound context = %+v", hook.lastInbound) + } select { case evt := <-hook.eventCh: if evt.Kind != EventKindTurnEnd { t.Fatalf("expected turn end event, got %v", evt.Kind) } + if evt.Meta.Context == nil || evt.Meta.Context.Inbound == nil { + t.Fatal("expected observer event to carry inbound context") + } case <-time.After(2 * time.Second): t.Fatal("timed out waiting for hook observer event") } diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go index 39a2e1539..8b388755a 100644 --- a/pkg/agent/loop.go +++ b/pkg/agent/loop.go @@ -91,6 +91,7 @@ type processOptions struct { SuppressToolFeedback bool // Whether to suppress inline tool feedback messages NoHistory bool // If true, don't load session history (for heartbeat) SkipInitialSteeringPoll bool // If true, skip the steering poll at loop start (used by Continue) + InboundContext *bus.InboundContext // Normalized inbound facts for events/hooks } type continuationTarget struct { @@ -750,14 +751,16 @@ type turnEventScope struct { agentID string sessionKey string turnID string + context *TurnContext } -func (al *AgentLoop) newTurnEventScope(agentID, sessionKey string) turnEventScope { +func (al *AgentLoop) newTurnEventScope(agentID, sessionKey string, turnCtx *TurnContext) turnEventScope { seq := al.turnSeq.Add(1) return turnEventScope{ agentID: agentID, sessionKey: sessionKey, turnID: fmt.Sprintf("%s-turn-%d", agentID, seq), + context: cloneTurnContext(turnCtx), } } @@ -769,13 +772,14 @@ func (ts turnEventScope) meta(iteration int, source, tracePath string) EventMeta Iteration: iteration, Source: source, TracePath: tracePath, + Context: cloneTurnContext(ts.context), } } func (al *AgentLoop) emitEvent(kind EventKind, meta EventMeta, payload any) { evt := Event{ Kind: kind, - Meta: meta, + Meta: cloneEventMeta(meta), Payload: payload, } @@ -1356,6 +1360,7 @@ func (al *AgentLoop) processMessage(ctx context.Context, msg bus.InboundMessage) DefaultResponse: defaultResponse, EnableSummary: true, SendResponse: false, + InboundContext: cloneInboundContext(&msg.Context), } // context-dependent commands check their own Runtime fields and report @@ -1535,7 +1540,8 @@ func (al *AgentLoop) runAgentLoop( } } - ts := newTurnState(agent, opts, al.newTurnEventScope(agent.ID, opts.SessionKey)) + turnScope := al.newTurnEventScope(agent.ID, opts.SessionKey, newTurnContext(opts.InboundContext)) + ts := newTurnState(agent, opts, turnScope) result, err := al.runTurn(ctx, ts) if err != nil { return "", err diff --git a/pkg/agent/subturn.go b/pkg/agent/subturn.go index f5ba412ab..e243d8ac0 100644 --- a/pkg/agent/subturn.go +++ b/pkg/agent/subturn.go @@ -366,10 +366,11 @@ func spawnSubTurn( SendResponse: false, NoHistory: true, // SubTurns don't use session history SkipInitialSteeringPoll: true, + InboundContext: cloneInboundContext(parentTS.opts.InboundContext), } // Create event scope for the child turn - scope := al.newTurnEventScope(agent.ID, childID) + scope := al.newTurnEventScope(agent.ID, childID, newTurnContext(opts.InboundContext)) // Create child turnState using the new API childTS := newTurnState(&agent, opts, scope) diff --git a/pkg/agent/turn.go b/pkg/agent/turn.go index e4970c519..3339b3418 100644 --- a/pkg/agent/turn.go +++ b/pkg/agent/turn.go @@ -55,6 +55,7 @@ type turnState struct { turnID string agentID string sessionKey string + turnCtx *TurnContext channel string chatID string @@ -115,6 +116,7 @@ func newTurnState(agent *AgentInstance, opts processOptions, scope turnEventScop turnID: scope.turnID, agentID: agent.ID, sessionKey: opts.SessionKey, + turnCtx: cloneTurnContext(scope.context), channel: opts.Channel, chatID: opts.ChatID, userMessage: opts.UserMessage, @@ -307,6 +309,7 @@ func (ts *turnState) eventMeta(source, tracePath string) EventMeta { Iteration: snap.Iteration, Source: source, TracePath: tracePath, + Context: cloneTurnContext(ts.turnCtx), } } diff --git a/pkg/agent/turn_context.go b/pkg/agent/turn_context.go new file mode 100644 index 000000000..a448e24cd --- /dev/null +++ b/pkg/agent/turn_context.go @@ -0,0 +1,53 @@ +package agent + +import "github.com/sipeed/picoclaw/pkg/bus" + +// TurnContext carries normalized turn-scoped facts that can be shared across +// events, hooks, and other runtime observers without re-parsing legacy fields. +type TurnContext struct { + Inbound *bus.InboundContext `json:"inbound,omitempty"` +} + +func newTurnContext(inbound *bus.InboundContext) *TurnContext { + if inbound == nil { + return nil + } + return &TurnContext{ + Inbound: cloneInboundContext(inbound), + } +} + +func cloneTurnContext(ctx *TurnContext) *TurnContext { + if ctx == nil { + return nil + } + cloned := *ctx + cloned.Inbound = cloneInboundContext(ctx.Inbound) + return &cloned +} + +func cloneInboundContext(ctx *bus.InboundContext) *bus.InboundContext { + if ctx == nil { + return nil + } + cloned := *ctx + cloned.ReplyHandles = cloneStringMap(ctx.ReplyHandles) + cloned.Raw = cloneStringMap(ctx.Raw) + return &cloned +} + +func cloneStringMap(src map[string]string) map[string]string { + if len(src) == 0 { + return nil + } + cloned := make(map[string]string, len(src)) + for k, v := range src { + cloned[k] = v + } + return cloned +} + +func cloneEventMeta(meta EventMeta) EventMeta { + meta.Context = cloneTurnContext(meta.Context) + return meta +} From e0ceea91f60e9c2dfed8d672adf6e2d6915ed12c Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 15:23:36 +0800 Subject: [PATCH 008/174] refactor(context): carry route and scope through runtime --- pkg/agent/eventbus_test.go | 33 +++++++- pkg/agent/events.go | 3 +- pkg/agent/hooks.go | 10 +++ pkg/agent/hooks_test.go | 36 ++++++++- pkg/agent/loop.go | 143 ++++++++++++++++++++++------------ pkg/agent/subturn.go | 6 +- pkg/agent/turn.go | 14 ++-- pkg/agent/turn_context.go | 49 ++++++++++-- pkg/bus/bus.go | 2 + pkg/bus/bus_test.go | 60 ++++++++++++++ pkg/bus/outbound_context.go | 63 +++++++++++++++ pkg/bus/types.go | 16 ++-- pkg/channels/manager.go | 4 + pkg/routing/session_key.go | 31 +++++--- pkg/session/allocator.go | 54 +++++++++++++ pkg/session/allocator_test.go | 15 ++++ pkg/session/scope.go | 32 ++++++++ 17 files changed, 487 insertions(+), 84 deletions(-) create mode 100644 pkg/bus/outbound_context.go create mode 100644 pkg/session/scope.go diff --git a/pkg/agent/eventbus_test.go b/pkg/agent/eventbus_test.go index 8706a2c4e..6a75ab8d9 100644 --- a/pkg/agent/eventbus_test.go +++ b/pkg/agent/eventbus_test.go @@ -10,6 +10,8 @@ import ( "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/config" "github.com/sipeed/picoclaw/pkg/providers" + "github.com/sipeed/picoclaw/pkg/routing" + "github.com/sipeed/picoclaw/pkg/session" "github.com/sipeed/picoclaw/pkg/tools" ) @@ -142,6 +144,25 @@ func TestAgentLoop_EmitsMinimalTurnEvents(t *testing.T) { ChatType: "direct", SenderID: "tester", }, + RouteResult: &routing.ResolvedRoute{ + AgentID: "main", + Channel: "cli", + AccountID: routing.DefaultAccountID, + SessionPolicy: routing.SessionPolicy{ + DMScope: routing.DMScopePerPeer, + }, + MatchedBy: "default", + }, + SessionScope: &session.SessionScope{ + Version: session.ScopeVersionV1, + AgentID: "main", + Channel: "cli", + Account: routing.DefaultAccountID, + Dimensions: []string{"sender"}, + Values: map[string]string{ + "sender": "tester", + }, + }, }) if err != nil { t.Fatalf("runAgentLoop failed: %v", err) @@ -182,11 +203,17 @@ func TestAgentLoop_EmitsMinimalTurnEvents(t *testing.T) { if evt.Meta.SessionKey != "session-1" { t.Fatalf("event %d has session key %q, want session-1", i, evt.Meta.SessionKey) } - if evt.Meta.Context == nil || evt.Meta.Context.Inbound == nil { + if evt.Context == nil || evt.Context.Inbound == nil { t.Fatalf("event %d missing inbound turn context", i) } - if evt.Meta.Context.Inbound.Channel != "cli" || evt.Meta.Context.Inbound.SenderID != "tester" { - t.Fatalf("event %d inbound context = %+v", i, evt.Meta.Context.Inbound) + if evt.Context.Inbound.Channel != "cli" || evt.Context.Inbound.SenderID != "tester" { + t.Fatalf("event %d inbound context = %+v", i, evt.Context.Inbound) + } + if evt.Context.Route == nil || evt.Context.Route.AgentID != "main" { + t.Fatalf("event %d missing route context: %+v", i, evt.Context.Route) + } + if evt.Context.Scope == nil || evt.Context.Scope.Values["sender"] != "tester" { + t.Fatalf("event %d missing session scope: %+v", i, evt.Context.Scope) } } diff --git a/pkg/agent/events.go b/pkg/agent/events.go index fa006b9a5..d17f5a90b 100644 --- a/pkg/agent/events.go +++ b/pkg/agent/events.go @@ -86,6 +86,7 @@ type Event struct { Kind EventKind Time time.Time Meta EventMeta + Context *TurnContext Payload any } @@ -98,7 +99,7 @@ type EventMeta struct { Iteration int TracePath string Source string - Context *TurnContext `json:"context,omitempty"` + turnContext *TurnContext } // TurnEndStatus describes the terminal state of a turn. diff --git a/pkg/agent/hooks.go b/pkg/agent/hooks.go index 7a5f8c59b..c3c4b21ce 100644 --- a/pkg/agent/hooks.go +++ b/pkg/agent/hooks.go @@ -89,6 +89,7 @@ type ToolApprover interface { type LLMHookRequest struct { Meta EventMeta `json:"meta"` + Context *TurnContext `json:"context,omitempty"` Model string `json:"model"` Messages []providers.Message `json:"messages,omitempty"` Tools []providers.ToolDefinition `json:"tools,omitempty"` @@ -104,6 +105,7 @@ func (r *LLMHookRequest) Clone() *LLMHookRequest { } cloned := *r cloned.Meta = cloneEventMeta(r.Meta) + cloned.Context = cloneTurnContext(r.Context) cloned.Messages = cloneProviderMessages(r.Messages) cloned.Tools = cloneToolDefinitions(r.Tools) cloned.Options = cloneStringAnyMap(r.Options) @@ -112,6 +114,7 @@ func (r *LLMHookRequest) Clone() *LLMHookRequest { type LLMHookResponse struct { Meta EventMeta `json:"meta"` + Context *TurnContext `json:"context,omitempty"` Model string `json:"model"` Response *providers.LLMResponse `json:"response,omitempty"` Channel string `json:"channel,omitempty"` @@ -124,12 +127,14 @@ func (r *LLMHookResponse) Clone() *LLMHookResponse { } cloned := *r cloned.Meta = cloneEventMeta(r.Meta) + cloned.Context = cloneTurnContext(r.Context) cloned.Response = cloneLLMResponse(r.Response) return &cloned } type ToolCallHookRequest struct { Meta EventMeta `json:"meta"` + Context *TurnContext `json:"context,omitempty"` Tool string `json:"tool"` Arguments map[string]any `json:"arguments,omitempty"` Channel string `json:"channel,omitempty"` @@ -142,12 +147,14 @@ func (r *ToolCallHookRequest) Clone() *ToolCallHookRequest { } cloned := *r cloned.Meta = cloneEventMeta(r.Meta) + cloned.Context = cloneTurnContext(r.Context) cloned.Arguments = cloneStringAnyMap(r.Arguments) return &cloned } type ToolApprovalRequest struct { Meta EventMeta `json:"meta"` + Context *TurnContext `json:"context,omitempty"` Tool string `json:"tool"` Arguments map[string]any `json:"arguments,omitempty"` Channel string `json:"channel,omitempty"` @@ -160,12 +167,14 @@ func (r *ToolApprovalRequest) Clone() *ToolApprovalRequest { } cloned := *r cloned.Meta = cloneEventMeta(r.Meta) + cloned.Context = cloneTurnContext(r.Context) cloned.Arguments = cloneStringAnyMap(r.Arguments) return &cloned } type ToolResultHookResponse struct { Meta EventMeta `json:"meta"` + Context *TurnContext `json:"context,omitempty"` Tool string `json:"tool"` Arguments map[string]any `json:"arguments,omitempty"` Result *tools.ToolResult `json:"result,omitempty"` @@ -180,6 +189,7 @@ func (r *ToolResultHookResponse) Clone() *ToolResultHookResponse { } cloned := *r cloned.Meta = cloneEventMeta(r.Meta) + cloned.Context = cloneTurnContext(r.Context) cloned.Arguments = cloneStringAnyMap(r.Arguments) cloned.Result = cloneToolResult(r.Result) return &cloned diff --git a/pkg/agent/hooks_test.go b/pkg/agent/hooks_test.go index 1851090b8..3287a2a1d 100644 --- a/pkg/agent/hooks_test.go +++ b/pkg/agent/hooks_test.go @@ -10,6 +10,8 @@ import ( "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/config" "github.com/sipeed/picoclaw/pkg/providers" + "github.com/sipeed/picoclaw/pkg/routing" + "github.com/sipeed/picoclaw/pkg/session" "github.com/sipeed/picoclaw/pkg/tools" ) @@ -124,8 +126,8 @@ func (h *llmObserverHook) BeforeLLM( ctx context.Context, req *LLMHookRequest, ) (*LLMHookRequest, HookDecision, error) { - if req.Meta.Context != nil { - h.lastInbound = cloneInboundContext(req.Meta.Context.Inbound) + if req.Context != nil { + h.lastInbound = cloneInboundContext(req.Context.Inbound) } next := req.Clone() next.Model = "hook-model" @@ -165,6 +167,25 @@ func TestAgentLoop_Hooks_ObserverAndLLMInterceptor(t *testing.T) { ChatType: "direct", SenderID: "hook-user", }, + RouteResult: &routing.ResolvedRoute{ + AgentID: "main", + Channel: "cli", + AccountID: routing.DefaultAccountID, + SessionPolicy: routing.SessionPolicy{ + DMScope: routing.DMScopePerPeer, + }, + MatchedBy: "default", + }, + SessionScope: &session.SessionScope{ + Version: session.ScopeVersionV1, + AgentID: "main", + Channel: "cli", + Account: routing.DefaultAccountID, + Dimensions: []string{"sender"}, + Values: map[string]string{ + "sender": "hook-user", + }, + }, }) if err != nil { t.Fatalf("runAgentLoop failed: %v", err) @@ -185,15 +206,24 @@ func TestAgentLoop_Hooks_ObserverAndLLMInterceptor(t *testing.T) { if hook.lastInbound.Channel != "cli" || hook.lastInbound.SenderID != "hook-user" { t.Fatalf("hook inbound context = %+v", hook.lastInbound) } + if hook.lastInbound != nil && hook.lastInbound.ChatID != "direct" { + t.Fatalf("hook inbound chat ID = %q, want direct", hook.lastInbound.ChatID) + } select { case evt := <-hook.eventCh: if evt.Kind != EventKindTurnEnd { t.Fatalf("expected turn end event, got %v", evt.Kind) } - if evt.Meta.Context == nil || evt.Meta.Context.Inbound == nil { + if evt.Context == nil || evt.Context.Inbound == nil { t.Fatal("expected observer event to carry inbound context") } + if evt.Context.Route == nil || evt.Context.Route.AgentID != "main" { + t.Fatalf("expected observer event to carry route context, got %+v", evt.Context.Route) + } + if evt.Context.Scope == nil || evt.Context.Scope.Values["sender"] != "hook-user" { + t.Fatalf("expected observer event to carry session scope, got %+v", evt.Context.Scope) + } case <-time.After(2 * time.Second): t.Fatal("timed out waiting for hook observer event") } diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go index 8b388755a..0b3c2fee4 100644 --- a/pkg/agent/loop.go +++ b/pkg/agent/loop.go @@ -73,25 +73,27 @@ type AgentLoop struct { // processOptions configures how a message is processed type processOptions struct { - SessionKey string // Session identifier for history/context - Channel string // Target channel for tool execution - ChatID string // Target chat ID for tool execution - MessageID string // Current inbound platform message ID - ReplyToMessageID string // Current inbound reply target message ID - SenderID string // Current sender ID for dynamic context - SenderDisplayName string // Current sender display name for dynamic context - UserMessage string // User message content (may include prefix) - ForcedSkills []string // Skills explicitly requested for this message - SystemPromptOverride string // Override the default system prompt (Used by SubTurns) - Media []string // media:// refs from inbound message - InitialSteeringMessages []providers.Message // Steering messages from refactor/agent - DefaultResponse string // Response when LLM returns empty - EnableSummary bool // Whether to trigger summarization - SendResponse bool // Whether to send response via bus - SuppressToolFeedback bool // Whether to suppress inline tool feedback messages - NoHistory bool // If true, don't load session history (for heartbeat) - SkipInitialSteeringPoll bool // If true, skip the steering poll at loop start (used by Continue) - InboundContext *bus.InboundContext // Normalized inbound facts for events/hooks + SessionKey string // Session identifier for history/context + Channel string // Target channel for tool execution + ChatID string // Target chat ID for tool execution + MessageID string // Current inbound platform message ID + ReplyToMessageID string // Current inbound reply target message ID + SenderID string // Current sender ID for dynamic context + SenderDisplayName string // Current sender display name for dynamic context + UserMessage string // User message content (may include prefix) + ForcedSkills []string // Skills explicitly requested for this message + SystemPromptOverride string // Override the default system prompt (Used by SubTurns) + Media []string // media:// refs from inbound message + InitialSteeringMessages []providers.Message // Steering messages from refactor/agent + DefaultResponse string // Response when LLM returns empty + EnableSummary bool // Whether to trigger summarization + SendResponse bool // Whether to send response via bus + SuppressToolFeedback bool // Whether to suppress inline tool feedback messages + NoHistory bool // If true, don't load session history (for heartbeat) + SkipInitialSteeringPoll bool // If true, skip the steering poll at loop start (used by Continue) + InboundContext *bus.InboundContext // Normalized inbound facts for events/hooks + RouteResult *routing.ResolvedRoute // Route decision snapshot for events/hooks + SessionScope *session.SessionScope // Session scope snapshot for events/hooks } type continuationTarget struct { @@ -705,6 +707,45 @@ func (al *AgentLoop) Close() { } } +func outboundContextFromInbound( + inbound *bus.InboundContext, + channel, chatID, replyToMessageID string, +) bus.InboundContext { + if inbound == nil { + return bus.ContextFromLegacyOutbound(bus.OutboundMessage{ + Channel: channel, + ChatID: chatID, + ReplyToMessageID: replyToMessageID, + }) + } + + outboundCtx := *cloneInboundContext(inbound) + if outboundCtx.Channel == "" { + outboundCtx.Channel = channel + } + if outboundCtx.ChatID == "" { + outboundCtx.ChatID = chatID + } + if outboundCtx.ReplyToMessageID == "" { + outboundCtx.ReplyToMessageID = replyToMessageID + } + return outboundCtx +} + +func outboundMessageForTurn(ts *turnState, content string) bus.OutboundMessage { + return bus.OutboundMessage{ + Channel: ts.channel, + ChatID: ts.chatID, + Context: outboundContextFromInbound( + ts.opts.InboundContext, + ts.channel, + ts.chatID, + ts.opts.ReplyToMessageID, + ), + Content: content, + } +} + // MountHook registers an in-process hook on the agent loop. func (al *AgentLoop) MountHook(reg HookRegistration) error { if al == nil || al.hooks == nil { @@ -766,20 +807,22 @@ func (al *AgentLoop) newTurnEventScope(agentID, sessionKey string, turnCtx *Turn func (ts turnEventScope) meta(iteration int, source, tracePath string) EventMeta { return EventMeta{ - AgentID: ts.agentID, - TurnID: ts.turnID, - SessionKey: ts.sessionKey, - Iteration: iteration, - Source: source, - TracePath: tracePath, - Context: cloneTurnContext(ts.context), + AgentID: ts.agentID, + TurnID: ts.turnID, + SessionKey: ts.sessionKey, + Iteration: iteration, + Source: source, + TracePath: tracePath, + turnContext: cloneTurnContext(ts.context), } } func (al *AgentLoop) emitEvent(kind EventKind, meta EventMeta, payload any) { + clonedMeta := cloneEventMeta(meta) evt := Event{ Kind: kind, - Meta: cloneEventMeta(meta), + Meta: clonedMeta, + Context: cloneTurnContext(clonedMeta.turnContext), Payload: payload, } @@ -1361,6 +1404,8 @@ func (al *AgentLoop) processMessage(ctx context.Context, msg bus.InboundMessage) EnableSummary: true, SendResponse: false, InboundContext: cloneInboundContext(&msg.Context), + RouteResult: cloneResolvedRoute(&route), + SessionScope: session.CloneScope(&allocation.Scope), } // context-dependent commands check their own Runtime fields and report @@ -1540,7 +1585,11 @@ func (al *AgentLoop) runAgentLoop( } } - turnScope := al.newTurnEventScope(agent.ID, opts.SessionKey, newTurnContext(opts.InboundContext)) + turnScope := al.newTurnEventScope( + agent.ID, + opts.SessionKey, + newTurnContext(opts.InboundContext, opts.RouteResult, opts.SessionScope), + ) ts := newTurnState(agent, opts, turnScope) result, err := al.runTurn(ctx, ts) if err != nil { @@ -1564,6 +1613,12 @@ func (al *AgentLoop) runAgentLoop( al.bus.PublishOutbound(ctx, bus.OutboundMessage{ Channel: opts.Channel, ChatID: opts.ChatID, + Context: outboundContextFromInbound( + opts.InboundContext, + opts.Channel, + opts.ChatID, + opts.ReplyToMessageID, + ), Content: result.finalContent, }) } @@ -1897,6 +1952,7 @@ turnLoop: if al.hooks != nil { llmReq, decision := al.hooks.BeforeLLM(turnCtx, &LLMHookRequest{ Meta: ts.eventMeta("runTurn", "turn.llm.request"), + Context: cloneTurnContext(ts.turnCtx), Model: llmModel, Messages: callMessages, Tools: providerToolDefs, @@ -2069,11 +2125,10 @@ turnLoop: ) if retry == 0 && !constants.IsInternalChannel(ts.channel) { - al.bus.PublishOutbound(ctx, bus.OutboundMessage{ - Channel: ts.channel, - ChatID: ts.chatID, - Content: "Context window exceeded. Compressing history and retrying...", - }) + al.bus.PublishOutbound(ctx, outboundMessageForTurn( + ts, + "Context window exceeded. Compressing history and retrying...", + )) } if compression, ok := al.forceCompression(ts.agent, ts.sessionKey); ok { @@ -2128,6 +2183,7 @@ turnLoop: if al.hooks != nil { llmResp, decision := al.hooks.AfterLLM(turnCtx, &LLMHookResponse{ Meta: ts.eventMeta("runTurn", "turn.llm.response"), + Context: cloneTurnContext(ts.turnCtx), Model: llmModel, Response: response, Channel: ts.channel, @@ -2280,6 +2336,7 @@ turnLoop: if al.hooks != nil { toolReq, decision := al.hooks.BeforeTool(turnCtx, &ToolCallHookRequest{ Meta: ts.eventMeta("runTurn", "turn.tool.before"), + Context: cloneTurnContext(ts.turnCtx), Tool: toolName, Arguments: toolArgs, Channel: ts.channel, @@ -2326,6 +2383,7 @@ turnLoop: if al.hooks != nil { approval := al.hooks.ApproveTool(turnCtx, &ToolApprovalRequest{ Meta: ts.eventMeta("runTurn", "turn.tool.approve"), + Context: cloneTurnContext(ts.turnCtx), Tool: toolName, Arguments: toolArgs, Channel: ts.channel, @@ -2383,11 +2441,7 @@ turnLoop: ) feedbackMsg := fmt.Sprintf("\U0001f527 `%s`\n```\n%s\n```", tc.Name, feedbackPreview) fbCtx, fbCancel := context.WithTimeout(turnCtx, 3*time.Second) - _ = al.bus.PublishOutbound(fbCtx, bus.OutboundMessage{ - Channel: ts.channel, - ChatID: ts.chatID, - Content: feedbackMsg, - }) + _ = al.bus.PublishOutbound(fbCtx, outboundMessageForTurn(ts, feedbackMsg)) fbCancel() } @@ -2400,11 +2454,7 @@ turnLoop: if !result.Silent && result.ForUser != "" { outCtx, outCancel := context.WithTimeout(context.Background(), 5*time.Second) defer outCancel() - _ = al.bus.PublishOutbound(outCtx, bus.OutboundMessage{ - Channel: ts.channel, - ChatID: ts.chatID, - Content: result.ForUser, - }) + _ = al.bus.PublishOutbound(outCtx, outboundMessageForTurn(ts, result.ForUser)) } // Determine content for the agent loop (ForLLM or error). @@ -2469,6 +2519,7 @@ turnLoop: if al.hooks != nil { toolResp, decision := al.hooks.AfterTool(turnCtx, &ToolResultHookResponse{ Meta: ts.eventMeta("runTurn", "turn.tool.after"), + Context: cloneTurnContext(ts.turnCtx), Tool: toolName, Arguments: toolArgs, Result: toolResult, @@ -2545,11 +2596,7 @@ turnLoop: } if !toolResult.Silent && toolResult.ForUser != "" && ts.opts.SendResponse { - al.bus.PublishOutbound(ctx, bus.OutboundMessage{ - Channel: ts.channel, - ChatID: ts.chatID, - Content: toolResult.ForUser, - }) + al.bus.PublishOutbound(ctx, outboundMessageForTurn(ts, toolResult.ForUser)) logger.DebugCF("agent", "Sent tool result to user", map[string]any{ "tool": toolName, diff --git a/pkg/agent/subturn.go b/pkg/agent/subturn.go index e243d8ac0..56439885a 100644 --- a/pkg/agent/subturn.go +++ b/pkg/agent/subturn.go @@ -370,7 +370,11 @@ func spawnSubTurn( } // Create event scope for the child turn - scope := al.newTurnEventScope(agent.ID, childID, newTurnContext(opts.InboundContext)) + scope := al.newTurnEventScope( + agent.ID, + childID, + newTurnContext(opts.InboundContext, opts.RouteResult, opts.SessionScope), + ) // Create child turnState using the new API childTS := newTurnState(&agent, opts, scope) diff --git a/pkg/agent/turn.go b/pkg/agent/turn.go index 3339b3418..41a57d942 100644 --- a/pkg/agent/turn.go +++ b/pkg/agent/turn.go @@ -303,13 +303,13 @@ func (ts *turnState) hardAbortRequested() bool { func (ts *turnState) eventMeta(source, tracePath string) EventMeta { snap := ts.snapshot() return EventMeta{ - AgentID: snap.AgentID, - TurnID: snap.TurnID, - SessionKey: snap.SessionKey, - Iteration: snap.Iteration, - Source: source, - TracePath: tracePath, - Context: cloneTurnContext(ts.turnCtx), + AgentID: snap.AgentID, + TurnID: snap.TurnID, + SessionKey: snap.SessionKey, + Iteration: snap.Iteration, + Source: source, + TracePath: tracePath, + turnContext: cloneTurnContext(ts.turnCtx), } } diff --git a/pkg/agent/turn_context.go b/pkg/agent/turn_context.go index a448e24cd..95ed5a0f3 100644 --- a/pkg/agent/turn_context.go +++ b/pkg/agent/turn_context.go @@ -1,19 +1,31 @@ package agent -import "github.com/sipeed/picoclaw/pkg/bus" +import ( + "github.com/sipeed/picoclaw/pkg/bus" + "github.com/sipeed/picoclaw/pkg/routing" + "github.com/sipeed/picoclaw/pkg/session" +) // TurnContext carries normalized turn-scoped facts that can be shared across // events, hooks, and other runtime observers without re-parsing legacy fields. type TurnContext struct { - Inbound *bus.InboundContext `json:"inbound,omitempty"` + Inbound *bus.InboundContext `json:"inbound,omitempty"` + Route *routing.ResolvedRoute `json:"route,omitempty"` + Scope *session.SessionScope `json:"scope,omitempty"` } -func newTurnContext(inbound *bus.InboundContext) *TurnContext { - if inbound == nil { +func newTurnContext( + inbound *bus.InboundContext, + route *routing.ResolvedRoute, + scope *session.SessionScope, +) *TurnContext { + if inbound == nil && route == nil && scope == nil { return nil } return &TurnContext{ Inbound: cloneInboundContext(inbound), + Route: cloneResolvedRoute(route), + Scope: session.CloneScope(scope), } } @@ -23,6 +35,8 @@ func cloneTurnContext(ctx *TurnContext) *TurnContext { } cloned := *ctx cloned.Inbound = cloneInboundContext(ctx.Inbound) + cloned.Route = cloneResolvedRoute(ctx.Route) + cloned.Scope = session.CloneScope(ctx.Scope) return &cloned } @@ -48,6 +62,31 @@ func cloneStringMap(src map[string]string) map[string]string { } func cloneEventMeta(meta EventMeta) EventMeta { - meta.Context = cloneTurnContext(meta.Context) + meta.turnContext = cloneTurnContext(meta.turnContext) return meta } + +func cloneResolvedRoute(route *routing.ResolvedRoute) *routing.ResolvedRoute { + if route == nil { + return nil + } + cloned := *route + cloned.SessionPolicy = routing.SessionPolicy{ + DMScope: route.SessionPolicy.DMScope, + IdentityLinks: cloneIdentityLinks(route.SessionPolicy.IdentityLinks), + } + return &cloned +} + +func cloneIdentityLinks(src map[string][]string) map[string][]string { + if len(src) == 0 { + return nil + } + cloned := make(map[string][]string, len(src)) + for canonical, ids := range src { + dup := make([]string, len(ids)) + copy(dup, ids) + cloned[canonical] = dup + } + return cloned +} diff --git a/pkg/bus/bus.go b/pkg/bus/bus.go index f6a339ff0..3e7ec9cdc 100644 --- a/pkg/bus/bus.go +++ b/pkg/bus/bus.go @@ -89,6 +89,7 @@ func (mb *MessageBus) InboundChan() <-chan InboundMessage { } func (mb *MessageBus) PublishOutbound(ctx context.Context, msg OutboundMessage) error { + msg = NormalizeOutboundMessage(msg) return publish(ctx, mb, mb.outbound, msg) } @@ -97,6 +98,7 @@ func (mb *MessageBus) OutboundChan() <-chan OutboundMessage { } func (mb *MessageBus) PublishOutboundMedia(ctx context.Context, msg OutboundMediaMessage) error { + msg = NormalizeOutboundMediaMessage(msg) return publish(ctx, mb, mb.outboundMedia, msg) } diff --git a/pkg/bus/bus_test.go b/pkg/bus/bus_test.go index ab79c0d49..087c0a65e 100644 --- a/pkg/bus/bus_test.go +++ b/pkg/bus/bus_test.go @@ -181,6 +181,66 @@ func TestPublishOutboundSubscribe(t *testing.T) { } } +func TestPublishOutbound_MirrorsContextToLegacyFields(t *testing.T) { + mb := NewMessageBus() + defer mb.Close() + + msg := OutboundMessage{ + Context: InboundContext{ + Channel: "telegram", + ChatID: "chat-42", + ReplyToMessageID: "msg-9", + }, + Content: "reply", + } + + if err := mb.PublishOutbound(context.Background(), msg); err != nil { + t.Fatalf("PublishOutbound failed: %v", err) + } + + got := <-mb.OutboundChan() + if got.Channel != "telegram" { + t.Fatalf("expected legacy channel telegram, got %q", got.Channel) + } + if got.ChatID != "chat-42" { + t.Fatalf("expected legacy chat ID chat-42, got %q", got.ChatID) + } + if got.ReplyToMessageID != "msg-9" { + t.Fatalf("expected mirrored reply_to_message_id msg-9, got %q", got.ReplyToMessageID) + } + if got.Context.Channel != "telegram" || got.Context.ChatID != "chat-42" { + t.Fatalf("unexpected outbound context: %+v", got.Context) + } +} + +func TestPublishOutboundMedia_MirrorsContextToLegacyFields(t *testing.T) { + mb := NewMessageBus() + defer mb.Close() + + msg := OutboundMediaMessage{ + Context: InboundContext{ + Channel: "slack", + ChatID: "C001", + }, + Parts: []MediaPart{{Type: "image", Ref: "media://1"}}, + } + + if err := mb.PublishOutboundMedia(context.Background(), msg); err != nil { + t.Fatalf("PublishOutboundMedia failed: %v", err) + } + + got := <-mb.OutboundMediaChan() + if got.Channel != "slack" { + t.Fatalf("expected legacy channel slack, got %q", got.Channel) + } + if got.ChatID != "C001" { + t.Fatalf("expected legacy chat ID C001, got %q", got.ChatID) + } + if got.Context.Channel != "slack" || got.Context.ChatID != "C001" { + t.Fatalf("unexpected outbound media context: %+v", got.Context) + } +} + func TestPublishInbound_ContextCancel(t *testing.T) { mb := NewMessageBus() defer mb.Close() diff --git a/pkg/bus/outbound_context.go b/pkg/bus/outbound_context.go new file mode 100644 index 000000000..e02353ea9 --- /dev/null +++ b/pkg/bus/outbound_context.go @@ -0,0 +1,63 @@ +package bus + +import "strings" + +// ContextFromLegacyOutbound builds a minimal outbound context from the legacy +// top-level outbound fields. This keeps older outbound publishers working +// while new publishers gradually start carrying the original InboundContext. +func ContextFromLegacyOutbound(msg OutboundMessage) InboundContext { + return normalizeInboundContext(InboundContext{ + Channel: strings.TrimSpace(msg.Channel), + ChatID: strings.TrimSpace(msg.ChatID), + ReplyToMessageID: strings.TrimSpace(msg.ReplyToMessageID), + }) +} + +// ContextFromLegacyOutboundMedia builds a minimal outbound context for media. +func ContextFromLegacyOutboundMedia(msg OutboundMediaMessage) InboundContext { + return normalizeInboundContext(InboundContext{ + Channel: strings.TrimSpace(msg.Channel), + ChatID: strings.TrimSpace(msg.ChatID), + }) +} + +// NormalizeOutboundMessage ensures Context is present and mirrors legacy +// top-level addressing fields from it so older senders keep working. +func NormalizeOutboundMessage(msg OutboundMessage) OutboundMessage { + if msg.Context.isZero() { + msg.Context = ContextFromLegacyOutbound(msg) + } else { + msg.Context = normalizeInboundContext(msg.Context) + } + + if msg.Channel == "" { + msg.Channel = msg.Context.Channel + } + if msg.ChatID == "" { + msg.ChatID = msg.Context.ChatID + } + if msg.ReplyToMessageID == "" { + msg.ReplyToMessageID = msg.Context.ReplyToMessageID + } + + return msg +} + +// NormalizeOutboundMediaMessage ensures media outbound messages also carry a +// normalized context while preserving the legacy top-level routing fields. +func NormalizeOutboundMediaMessage(msg OutboundMediaMessage) OutboundMediaMessage { + if msg.Context.isZero() { + msg.Context = ContextFromLegacyOutboundMedia(msg) + } else { + msg.Context = normalizeInboundContext(msg.Context) + } + + if msg.Channel == "" { + msg.Channel = msg.Context.Channel + } + if msg.ChatID == "" { + msg.ChatID = msg.Context.ChatID + } + + return msg +} diff --git a/pkg/bus/types.go b/pkg/bus/types.go index 0c4cd707b..f844ab1e0 100644 --- a/pkg/bus/types.go +++ b/pkg/bus/types.go @@ -58,10 +58,11 @@ type InboundMessage struct { } type OutboundMessage struct { - Channel string `json:"channel"` - ChatID string `json:"chat_id"` - Content string `json:"content"` - ReplyToMessageID string `json:"reply_to_message_id,omitempty"` + Channel string `json:"channel"` + ChatID string `json:"chat_id"` + Context InboundContext `json:"context"` + Content string `json:"content"` + ReplyToMessageID string `json:"reply_to_message_id,omitempty"` } // MediaPart describes a single media attachment to send. @@ -75,7 +76,8 @@ type MediaPart struct { // OutboundMediaMessage carries media attachments from Agent to channels via the bus. type OutboundMediaMessage struct { - Channel string `json:"channel"` - ChatID string `json:"chat_id"` - Parts []MediaPart `json:"parts"` + Channel string `json:"channel"` + ChatID string `json:"chat_id"` + Context InboundContext `json:"context"` + Parts []MediaPart `json:"parts"` } diff --git a/pkg/channels/manager.go b/pkg/channels/manager.go index 5fbf35ebf..76d1e67c5 100644 --- a/pkg/channels/manager.go +++ b/pkg/channels/manager.go @@ -1130,6 +1130,8 @@ func (m *Manager) UnregisterChannel(name string) { // delivered (or all retries are exhausted), which preserves ordering when // a subsequent operation depends on the message having been sent. func (m *Manager) SendMessage(ctx context.Context, msg bus.OutboundMessage) error { + msg = bus.NormalizeOutboundMessage(msg) + m.mu.RLock() _, exists := m.channels[msg.Channel] w, wExists := m.workers[msg.Channel] @@ -1163,6 +1165,8 @@ func (m *Manager) SendMessage(ctx context.Context, msg bus.OutboundMessage) erro // retries are exhausted), which preserves ordering when later agent behavior // depends on actual media delivery. func (m *Manager) SendMedia(ctx context.Context, msg bus.OutboundMediaMessage) error { + msg = bus.NormalizeOutboundMediaMessage(msg) + m.mu.RLock() _, exists := m.channels[msg.Channel] w, wExists := m.workers[msg.Channel] diff --git a/pkg/routing/session_key.go b/pkg/routing/session_key.go index eab592bec..17b62f4b7 100644 --- a/pkg/routing/session_key.go +++ b/pkg/routing/session_key.go @@ -60,15 +60,7 @@ func BuildAgentPeerSessionKey(params SessionKeyParams) string { if dmScope == "" { dmScope = DMScopeMain } - peerID := strings.TrimSpace(peer.ID) - - // Resolve identity links (cross-platform collapse) - if dmScope != DMScopeMain && peerID != "" { - if linked := resolveLinkedPeerID(params.IdentityLinks, params.Channel, peerID); linked != "" { - peerID = linked - } - } - peerID = strings.ToLower(peerID) + peerID := CanonicalSessionPeerID(params.Channel, peer.ID, dmScope, params.IdentityLinks) switch dmScope { case DMScopePerAccountChannelPeer: @@ -99,6 +91,27 @@ func BuildAgentPeerSessionKey(params SessionKeyParams) string { return fmt.Sprintf("agent:%s:%s:%s:%s", agentID, channel, peerKind, peerID) } +// CanonicalSessionPeerID applies the current DM session canonicalization rules, +// including identity-link collapse when enabled. +func CanonicalSessionPeerID( + channel, peerID string, + dmScope DMScope, + identityLinks map[string][]string, +) string { + normalizedPeerID := strings.TrimSpace(peerID) + if normalizedPeerID == "" { + return "" + } + + if dmScope != DMScopeMain { + if linked := resolveLinkedPeerID(identityLinks, channel, normalizedPeerID); linked != "" { + normalizedPeerID = linked + } + } + + return strings.ToLower(normalizedPeerID) +} + // ParseAgentSessionKey extracts agentId and rest from "agent::". func ParseAgentSessionKey(sessionKey string) *ParsedSessionKey { raw := strings.TrimSpace(sessionKey) diff --git a/pkg/session/allocator.go b/pkg/session/allocator.go index 675e577f8..a3b8e075d 100644 --- a/pkg/session/allocator.go +++ b/pkg/session/allocator.go @@ -1,6 +1,7 @@ package session import ( + "fmt" "strings" "github.com/sipeed/picoclaw/pkg/routing" @@ -10,6 +11,7 @@ import ( // The current implementation intentionally preserves the legacy session-key // layout while moving key construction out of the router. type Allocation struct { + Scope SessionScope SessionKey string MainSessionKey string } @@ -27,6 +29,7 @@ type AllocationInput struct { // AllocateRouteSession maps a route decision onto the current legacy // agent-scoped session-key format. func AllocateRouteSession(input AllocationInput) Allocation { + scope := buildSessionScope(input) sessionKey := strings.ToLower(routing.BuildAgentPeerSessionKey(routing.SessionKeyParams{ AgentID: input.AgentID, Channel: input.Channel, @@ -37,7 +40,58 @@ func AllocateRouteSession(input AllocationInput) Allocation { })) mainSessionKey := strings.ToLower(routing.BuildAgentMainSessionKey(input.AgentID)) return Allocation{ + Scope: scope, SessionKey: sessionKey, MainSessionKey: mainSessionKey, } } + +func buildSessionScope(input AllocationInput) SessionScope { + scope := SessionScope{ + Version: ScopeVersionV1, + AgentID: routing.NormalizeAgentID(input.AgentID), + Channel: strings.ToLower(strings.TrimSpace(input.Channel)), + Account: routing.NormalizeAccountID(input.AccountID), + } + + peer := input.Peer + if peer == nil { + peer = &routing.RoutePeer{Kind: "direct"} + } + + peerKind := strings.ToLower(strings.TrimSpace(peer.Kind)) + if peerKind == "" { + peerKind = "direct" + } + + switch peerKind { + case "direct": + if input.SessionPolicy.DMScope == routing.DMScopeMain { + return scope + } + peerID := routing.CanonicalSessionPeerID( + input.Channel, + peer.ID, + input.SessionPolicy.DMScope, + input.SessionPolicy.IdentityLinks, + ) + if peerID == "" { + return scope + } + scope.Dimensions = []string{"sender"} + scope.Values = map[string]string{ + "sender": peerID, + } + default: + peerID := strings.ToLower(strings.TrimSpace(peer.ID)) + if peerID == "" { + peerID = "unknown" + } + scope.Dimensions = []string{"chat"} + scope.Values = map[string]string{ + "chat": fmt.Sprintf("%s:%s", peerKind, peerID), + } + } + + return scope +} diff --git a/pkg/session/allocator_test.go b/pkg/session/allocator_test.go index a6e84e09d..5eb442e98 100644 --- a/pkg/session/allocator_test.go +++ b/pkg/session/allocator_test.go @@ -26,6 +26,15 @@ func TestAllocateRouteSession_PerPeerDM(t *testing.T) { if allocation.MainSessionKey != "agent:main:main" { t.Fatalf("MainSessionKey = %q, want %q", allocation.MainSessionKey, "agent:main:main") } + if allocation.Scope.Version != ScopeVersionV1 { + t.Fatalf("Scope.Version = %d, want %d", allocation.Scope.Version, ScopeVersionV1) + } + if len(allocation.Scope.Dimensions) != 1 || allocation.Scope.Dimensions[0] != "sender" { + t.Fatalf("Scope.Dimensions = %v, want [sender]", allocation.Scope.Dimensions) + } + if allocation.Scope.Values["sender"] != "user123" { + t.Fatalf("Scope.Values[sender] = %q, want user123", allocation.Scope.Values["sender"]) + } } func TestAllocateRouteSession_GroupPeer(t *testing.T) { @@ -48,4 +57,10 @@ func TestAllocateRouteSession_GroupPeer(t *testing.T) { if allocation.MainSessionKey != "agent:main:main" { t.Fatalf("MainSessionKey = %q, want %q", allocation.MainSessionKey, "agent:main:main") } + if len(allocation.Scope.Dimensions) != 1 || allocation.Scope.Dimensions[0] != "chat" { + t.Fatalf("Scope.Dimensions = %v, want [chat]", allocation.Scope.Dimensions) + } + if allocation.Scope.Values["chat"] != "channel:c001" { + t.Fatalf("Scope.Values[chat] = %q, want channel:c001", allocation.Scope.Values["chat"]) + } } diff --git a/pkg/session/scope.go b/pkg/session/scope.go new file mode 100644 index 000000000..efb026ea3 --- /dev/null +++ b/pkg/session/scope.go @@ -0,0 +1,32 @@ +package session + +// ScopeVersionV1 is the first structured session-scope schema version. +const ScopeVersionV1 = 1 + +// SessionScope describes the semantic session partition selected for a turn. +type SessionScope struct { + Version int `json:"version"` + AgentID string `json:"agent_id"` + Channel string `json:"channel"` + Account string `json:"account"` + Dimensions []string `json:"dimensions"` + Values map[string]string `json:"values"` +} + +// CloneScope returns a deep copy of scope. +func CloneScope(scope *SessionScope) *SessionScope { + if scope == nil { + return nil + } + cloned := *scope + if len(scope.Dimensions) > 0 { + cloned.Dimensions = append([]string(nil), scope.Dimensions...) + } + if len(scope.Values) > 0 { + cloned.Values = make(map[string]string, len(scope.Values)) + for key, value := range scope.Values { + cloned.Values[key] = value + } + } + return &cloned +} From bb2167e3f3ae841f0d941f2daec1256e83bceb99 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 15:46:35 +0800 Subject: [PATCH 009/174] feat(event): log turn context fields --- pkg/agent/loop.go | 83 ++++++++++++++++++++++++++++++++++++++++++ pkg/agent/loop_test.go | 67 ++++++++++++++++++++++++++++++++++ 2 files changed, 150 insertions(+) diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go index 0b3c2fee4..b4574bbb0 100644 --- a/pkg/agent/loop.go +++ b/pkg/agent/loop.go @@ -888,6 +888,8 @@ func (al *AgentLoop) logEvent(evt Event) { fields["source"] = evt.Meta.Source } + appendEventContextFields(fields, evt.Context) + switch payload := evt.Payload.(type) { case TurnStartPayload: fields["channel"] = payload.Channel @@ -971,6 +973,87 @@ func (al *AgentLoop) logEvent(evt Event) { logger.InfoCF("eventbus", fmt.Sprintf("Agent event: %s", evt.Kind.String()), fields) } +func appendEventContextFields(fields map[string]any, turnCtx *TurnContext) { + if turnCtx == nil { + return + } + + if inbound := turnCtx.Inbound; inbound != nil { + if inbound.Channel != "" { + fields["inbound_channel"] = inbound.Channel + } + if inbound.Account != "" { + fields["inbound_account"] = inbound.Account + } + if inbound.ChatID != "" { + fields["inbound_chat_id"] = inbound.ChatID + } + if inbound.ChatType != "" { + fields["inbound_chat_type"] = inbound.ChatType + } + if inbound.TopicID != "" { + fields["inbound_topic_id"] = inbound.TopicID + } + if inbound.SpaceType != "" { + fields["inbound_space_type"] = inbound.SpaceType + } + if inbound.SpaceID != "" { + fields["inbound_space_id"] = inbound.SpaceID + } + if inbound.SenderID != "" { + fields["inbound_sender_id"] = inbound.SenderID + } + if inbound.Mentioned { + fields["inbound_mentioned"] = true + } + } + + if route := turnCtx.Route; route != nil { + if route.AgentID != "" { + fields["route_agent_id"] = route.AgentID + } + if route.Channel != "" { + fields["route_channel"] = route.Channel + } + if route.AccountID != "" { + fields["route_account_id"] = route.AccountID + } + if route.MatchedBy != "" { + fields["route_matched_by"] = route.MatchedBy + } + if route.SessionPolicy.DMScope != "" { + fields["route_dm_scope"] = string(route.SessionPolicy.DMScope) + } + if count := len(route.SessionPolicy.IdentityLinks); count > 0 { + fields["route_identity_link_count"] = count + } + } + + if scope := turnCtx.Scope; scope != nil { + if scope.Version > 0 { + fields["scope_version"] = scope.Version + } + if scope.AgentID != "" { + fields["scope_agent_id"] = scope.AgentID + } + if scope.Channel != "" { + fields["scope_channel"] = scope.Channel + } + if scope.Account != "" { + fields["scope_account"] = scope.Account + } + if len(scope.Dimensions) > 0 { + fields["scope_dimensions"] = strings.Join(scope.Dimensions, ",") + } + for dim, value := range scope.Values { + if dim == "" || value == "" { + continue + } + fields["scope_"+dim] = value + } + } +} + func (al *AgentLoop) RegisterTool(tool tools.Tool) { registry := al.GetRegistry() for _, agentID := range registry.ListAgentIDs() { diff --git a/pkg/agent/loop_test.go b/pkg/agent/loop_test.go index 1f99a5085..dbc1b674b 100644 --- a/pkg/agent/loop_test.go +++ b/pkg/agent/loop_test.go @@ -20,6 +20,7 @@ import ( "github.com/sipeed/picoclaw/pkg/media" "github.com/sipeed/picoclaw/pkg/providers" "github.com/sipeed/picoclaw/pkg/routing" + "github.com/sipeed/picoclaw/pkg/session" "github.com/sipeed/picoclaw/pkg/tools" ) @@ -774,6 +775,72 @@ func TestExtractParentPeer_UsesInboundContextTopicID(t *testing.T) { } } +func TestAppendEventContextFields_IncludesInboundRouteAndScope(t *testing.T) { + fields := map[string]any{} + + appendEventContextFields(fields, &TurnContext{ + Inbound: &bus.InboundContext{ + Channel: "slack", + Account: "workspace-a", + ChatID: "C123", + ChatType: "channel", + TopicID: "thread-42", + SpaceType: "workspace", + SpaceID: "T001", + SenderID: "U123", + Mentioned: true, + }, + Route: &routing.ResolvedRoute{ + AgentID: "support", + Channel: "slack", + AccountID: "workspace-a", + MatchedBy: "binding.team", + SessionPolicy: routing.SessionPolicy{ + DMScope: routing.DMScopePerChannelPeer, + IdentityLinks: map[string][]string{ + "canonical-user": {"slack:U123"}, + }, + }, + }, + Scope: &session.SessionScope{ + Version: session.ScopeVersionV1, + AgentID: "support", + Channel: "slack", + Account: "workspace-a", + Dimensions: []string{"chat", "sender"}, + Values: map[string]string{ + "chat": "channel:c123", + "sender": "u123", + }, + }, + }) + + if fields["inbound_channel"] != "slack" { + t.Fatalf("inbound_channel = %v, want slack", fields["inbound_channel"]) + } + if fields["inbound_topic_id"] != "thread-42" { + t.Fatalf("inbound_topic_id = %v, want thread-42", fields["inbound_topic_id"]) + } + if fields["route_matched_by"] != "binding.team" { + t.Fatalf("route_matched_by = %v, want binding.team", fields["route_matched_by"]) + } + if fields["route_dm_scope"] != string(routing.DMScopePerChannelPeer) { + t.Fatalf("route_dm_scope = %v, want %q", fields["route_dm_scope"], routing.DMScopePerChannelPeer) + } + if fields["route_identity_link_count"] != 1 { + t.Fatalf("route_identity_link_count = %v, want 1", fields["route_identity_link_count"]) + } + if fields["scope_dimensions"] != "chat,sender" { + t.Fatalf("scope_dimensions = %v, want chat,sender", fields["scope_dimensions"]) + } + if fields["scope_chat"] != "channel:c123" { + t.Fatalf("scope_chat = %v, want channel:c123", fields["scope_chat"]) + } + if fields["scope_sender"] != "u123" { + t.Fatalf("scope_sender = %v, want u123", fields["scope_sender"]) + } +} + func TestResolveMessageRoute_UsesInboundContextAccountAndSpace(t *testing.T) { tmpDir := t.TempDir() cfg := &config.Config{ From 3957e2cc72aba69b0a7bcc7811e8bbd32ad9f96c Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 16:25:05 +0800 Subject: [PATCH 010/174] feat(session): persist scope metadata and aliases --- pkg/agent/loop.go | 41 +++++ pkg/memory/jsonl.go | 171 ++++++++++++++++++-- pkg/memory/jsonl_test.go | 55 +++++++ pkg/session/jsonl_backend.go | 64 ++++++++ pkg/session/jsonl_backend_test.go | 28 ++++ web/backend/api/session.go | 253 +++++++++++++++++++----------- web/backend/api/session_test.go | 77 +++++++++ 7 files changed, 585 insertions(+), 104 deletions(-) diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go index b4574bbb0..ef4680e45 100644 --- a/pkg/agent/loop.go +++ b/pkg/agent/loop.go @@ -74,6 +74,7 @@ type AgentLoop struct { // processOptions configures how a message is processed type processOptions struct { SessionKey string // Session identifier for history/context + SessionAliases []string // Compatibility aliases for the session key Channel string // Target channel for tool execution ChatID string // Target chat ID for tool execution MessageID string // Current inbound platform message ID @@ -1475,6 +1476,7 @@ func (al *AgentLoop) processMessage(ctx context.Context, msg bus.InboundMessage) opts := processOptions{ SessionKey: sessionKey, + SessionAliases: buildSessionAliases(sessionKey, allocation.SessionKey, msg.SessionKey), Channel: msg.Channel, ChatID: msg.ChatID, MessageID: msg.MessageID, @@ -1547,6 +1549,43 @@ func resolveScopeKey(routeSessionKey, msgSessionKey string) string { return routeSessionKey } +func buildSessionAliases(canonicalKey string, keys ...string) []string { + if len(keys) == 0 { + return nil + } + aliases := make([]string, 0, len(keys)) + seen := make(map[string]struct{}, len(keys)) + canonicalKey = strings.TrimSpace(canonicalKey) + for _, key := range keys { + key = strings.TrimSpace(key) + if key == "" || key == canonicalKey { + continue + } + if _, ok := seen[key]; ok { + continue + } + seen[key] = struct{}{} + aliases = append(aliases, key) + } + if len(aliases) == 0 { + return nil + } + return aliases +} + +func ensureSessionMetadata(store session.SessionStore, key string, scope *session.SessionScope, aliases []string) { + if key == "" || scope == nil { + return + } + metaStore, ok := store.(interface { + EnsureSessionMetadata(sessionKey string, scope *session.SessionScope, aliases []string) + }) + if !ok { + return + } + metaStore.EnsureSessionMetadata(key, scope, aliases) +} + func (al *AgentLoop) allocateRouteSession(route routing.ResolvedRoute, msg bus.InboundMessage) session.Allocation { return session.AllocateRouteSession(session.AllocationInput{ AgentID: route.AgentID, @@ -1668,6 +1707,8 @@ func (al *AgentLoop) runAgentLoop( } } + ensureSessionMetadata(agent.Sessions, opts.SessionKey, opts.SessionScope, opts.SessionAliases) + turnScope := al.newTurnEventScope( agent.ID, opts.SessionKey, diff --git a/pkg/memory/jsonl.go b/pkg/memory/jsonl.go index afe374166..70c55329f 100644 --- a/pkg/memory/jsonl.go +++ b/pkg/memory/jsonl.go @@ -32,14 +32,19 @@ const ( maxLineSize = 10 * 1024 * 1024 // 10 MB ) -// sessionMeta holds per-session metadata stored in a .meta.json file. -type sessionMeta struct { - Key string `json:"key"` - Summary string `json:"summary"` - Skip int `json:"skip"` - Count int `json:"count"` - CreatedAt time.Time `json:"created_at"` - UpdatedAt time.Time `json:"updated_at"` +// SessionMeta holds per-session metadata stored in a .meta.json file. +// +// Scope is stored as raw JSON so pkg/memory can stay decoupled from the +// higher-level session package while still preserving structured scope data. +type SessionMeta struct { + Key string `json:"key"` + Summary string `json:"summary"` + Skip int `json:"skip"` + Count int `json:"count"` + CreatedAt time.Time `json:"created_at"` + UpdatedAt time.Time `json:"updated_at"` + Scope json.RawMessage `json:"scope,omitempty"` + Aliases []string `json:"aliases,omitempty"` } // JSONLStore implements Store using append-only JSONL files. @@ -98,25 +103,31 @@ func sanitizeKey(key string) string { // readMeta loads the metadata file for a session. // Returns a zero-value sessionMeta if the file does not exist. -func (s *JSONLStore) readMeta(key string) (sessionMeta, error) { +func (s *JSONLStore) readMeta(key string) (SessionMeta, error) { data, err := os.ReadFile(s.metaPath(key)) if os.IsNotExist(err) { - return sessionMeta{Key: key}, nil + return SessionMeta{Key: key}, nil } if err != nil { - return sessionMeta{}, fmt.Errorf("memory: read meta: %w", err) + return SessionMeta{}, fmt.Errorf("memory: read meta: %w", err) } - var meta sessionMeta + var meta SessionMeta err = json.Unmarshal(data, &meta) if err != nil { - return sessionMeta{}, fmt.Errorf("memory: decode meta: %w", err) + return SessionMeta{}, fmt.Errorf("memory: decode meta: %w", err) + } + if meta.Key == "" { + meta.Key = key } return meta, nil } // writeMeta atomically writes the metadata file using the project's // standard WriteFileAtomic (temp + fsync + rename). -func (s *JSONLStore) writeMeta(key string, meta sessionMeta) error { +func (s *JSONLStore) writeMeta(key string, meta SessionMeta) error { + if strings.TrimSpace(meta.Key) == "" { + meta.Key = key + } data, err := json.MarshalIndent(meta, "", " ") if err != nil { return fmt.Errorf("memory: encode meta: %w", err) @@ -124,6 +135,138 @@ func (s *JSONLStore) writeMeta(key string, meta sessionMeta) error { return fileutil.WriteFileAtomic(s.metaPath(key), data, 0o644) } +func cloneRawJSON(data json.RawMessage) json.RawMessage { + if len(data) == 0 { + return nil + } + return append(json.RawMessage(nil), data...) +} + +func normalizeAliases(canonicalKey string, aliases []string) []string { + if len(aliases) == 0 { + return nil + } + normalized := make([]string, 0, len(aliases)) + seen := make(map[string]struct{}, len(aliases)) + canonicalKey = strings.TrimSpace(canonicalKey) + for _, alias := range aliases { + alias = strings.TrimSpace(alias) + if alias == "" || alias == canonicalKey { + continue + } + if _, ok := seen[alias]; ok { + continue + } + seen[alias] = struct{}{} + normalized = append(normalized, alias) + } + if len(normalized) == 0 { + return nil + } + return normalized +} + +func (s *JSONLStore) sessionExists(key string) bool { + if key == "" { + return false + } + if _, err := os.Stat(s.jsonlPath(key)); err == nil { + return true + } + if _, err := os.Stat(s.metaPath(key)); err == nil { + return true + } + return false +} + +// GetSessionMeta returns the current metadata snapshot for sessionKey. +func (s *JSONLStore) GetSessionMeta(_ context.Context, sessionKey string) (SessionMeta, error) { + l := s.sessionLock(sessionKey) + l.Lock() + defer l.Unlock() + + meta, err := s.readMeta(sessionKey) + if err != nil { + return SessionMeta{}, err + } + meta.Scope = cloneRawJSON(meta.Scope) + if len(meta.Aliases) > 0 { + meta.Aliases = append([]string(nil), meta.Aliases...) + } + return meta, nil +} + +// UpsertSessionMeta stores structured session metadata while preserving +// summary/count/skip timestamps maintained by the core JSONL store. +func (s *JSONLStore) UpsertSessionMeta( + _ context.Context, + sessionKey string, + scope json.RawMessage, + aliases []string, +) error { + l := s.sessionLock(sessionKey) + l.Lock() + defer l.Unlock() + + meta, err := s.readMeta(sessionKey) + if err != nil { + return err + } + meta.Scope = cloneRawJSON(scope) + meta.Aliases = normalizeAliases(sessionKey, aliases) + now := time.Now() + if meta.CreatedAt.IsZero() { + meta.CreatedAt = now + } + meta.UpdatedAt = now + + return s.writeMeta(sessionKey, meta) +} + +// ResolveSessionKey returns the canonical session key for a candidate key. +// It first checks direct key existence, then scans metadata aliases on miss. +func (s *JSONLStore) ResolveSessionKey(_ context.Context, sessionKey string) (string, bool, error) { + sessionKey = strings.TrimSpace(sessionKey) + if sessionKey == "" { + return "", false, nil + } + if s.sessionExists(sessionKey) { + return sessionKey, true, nil + } + + entries, err := os.ReadDir(s.dir) + if err != nil { + return "", false, fmt.Errorf("memory: read sessions dir: %w", err) + } + + for _, entry := range entries { + if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".meta.json") { + continue + } + data, readErr := os.ReadFile(filepath.Join(s.dir, entry.Name())) + if readErr != nil { + return "", false, fmt.Errorf("memory: read meta: %w", readErr) + } + var meta SessionMeta + if err := json.Unmarshal(data, &meta); err != nil { + return "", false, fmt.Errorf("memory: decode meta: %w", err) + } + if meta.Key == "" { + continue + } + if meta.Key == sessionKey { + return meta.Key, true, nil + } + for _, alias := range meta.Aliases { + if alias == sessionKey { + return meta.Key, true, nil + } + } + } + + return "", false, nil +} + // readMessages reads valid JSON lines from a .jsonl file, skipping // the first `skip` lines without unmarshaling them. This avoids the // cost of json.Unmarshal on logically truncated messages. diff --git a/pkg/memory/jsonl_test.go b/pkg/memory/jsonl_test.go index 356ff14ff..ef739e49b 100644 --- a/pkg/memory/jsonl_test.go +++ b/pkg/memory/jsonl_test.go @@ -2,8 +2,10 @@ package memory import ( "context" + "encoding/json" "os" "path/filepath" + "reflect" "sync" "testing" @@ -241,6 +243,59 @@ func TestSetSummary_GetSummary(t *testing.T) { } } +func TestSessionMetaScopeAndAliasesPersist(t *testing.T) { + store := newTestStore(t) + ctx := context.Background() + + scope := json.RawMessage(`{"version":1,"channel":"telegram","values":{"chat":"group:c1"}}`) + aliases := []string{"legacy:one", "legacy:one", "canonical"} + if err := store.UpsertSessionMeta(ctx, "canonical", scope, aliases); err != nil { + t.Fatalf("UpsertSessionMeta() error = %v", err) + } + + meta, err := store.GetSessionMeta(ctx, "canonical") + if err != nil { + t.Fatalf("GetSessionMeta() error = %v", err) + } + var gotScope map[string]any + if err := json.Unmarshal(meta.Scope, &gotScope); err != nil { + t.Fatalf("Unmarshal(meta.Scope) error = %v", err) + } + var wantScope map[string]any + if err := json.Unmarshal(scope, &wantScope); err != nil { + t.Fatalf("Unmarshal(scope) error = %v", err) + } + if !reflect.DeepEqual(gotScope, wantScope) { + t.Fatalf("meta.Scope = %#v, want %#v", gotScope, wantScope) + } + if len(meta.Aliases) != 1 || meta.Aliases[0] != "legacy:one" { + t.Fatalf("meta.Aliases = %#v, want [legacy:one]", meta.Aliases) + } +} + +func TestResolveSessionKeyByAlias(t *testing.T) { + store := newTestStore(t) + ctx := context.Background() + + if err := store.AddMessage(ctx, "canonical", "user", "hello"); err != nil { + t.Fatalf("AddMessage() error = %v", err) + } + if err := store.UpsertSessionMeta(ctx, "canonical", nil, []string{"legacy:key"}); err != nil { + t.Fatalf("UpsertSessionMeta() error = %v", err) + } + + resolved, found, err := store.ResolveSessionKey(ctx, "legacy:key") + if err != nil { + t.Fatalf("ResolveSessionKey() error = %v", err) + } + if !found { + t.Fatal("ResolveSessionKey() did not find alias") + } + if resolved != "canonical" { + t.Fatalf("resolved = %q, want %q", resolved, "canonical") + } +} + func TestTruncateHistory_KeepLast(t *testing.T) { store := newTestStore(t) ctx := context.Background() diff --git a/pkg/session/jsonl_backend.go b/pkg/session/jsonl_backend.go index 7f470de15..38a0c160e 100644 --- a/pkg/session/jsonl_backend.go +++ b/pkg/session/jsonl_backend.go @@ -2,6 +2,7 @@ package session import ( "context" + "encoding/json" "log" "github.com/sipeed/picoclaw/pkg/memory" @@ -15,24 +16,82 @@ type JSONLBackend struct { store memory.Store } +type metaAwareStore interface { + GetSessionMeta(ctx context.Context, sessionKey string) (memory.SessionMeta, error) + UpsertSessionMeta(ctx context.Context, sessionKey string, scope json.RawMessage, aliases []string) error + ResolveSessionKey(ctx context.Context, sessionKey string) (string, bool, error) +} + +// MetadataAwareSessionStore exposes structured session metadata operations. +type MetadataAwareSessionStore interface { + EnsureSessionMetadata(sessionKey string, scope *SessionScope, aliases []string) + ResolveSessionKey(sessionKey string) string +} + // NewJSONLBackend wraps a memory.Store for use as a SessionStore. func NewJSONLBackend(store memory.Store) *JSONLBackend { return &JSONLBackend{store: store} } +func (b *JSONLBackend) resolveSessionKey(sessionKey string) string { + metaStore, ok := b.store.(metaAwareStore) + if !ok { + return sessionKey + } + resolved, found, err := metaStore.ResolveSessionKey(context.Background(), sessionKey) + if err != nil { + log.Printf("session: resolve session key: %v", err) + return sessionKey + } + if found && resolved != "" { + return resolved + } + return sessionKey +} + +// ResolveSessionKey maps aliases onto their canonical session key when the +// underlying store supports structured metadata. Unknown aliases fall back to +// the original input so existing callers remain compatible. +func (b *JSONLBackend) ResolveSessionKey(sessionKey string) string { + return b.resolveSessionKey(sessionKey) +} + +// EnsureSessionMetadata persists scope and alias metadata for a session. +func (b *JSONLBackend) EnsureSessionMetadata(sessionKey string, scope *SessionScope, aliases []string) { + metaStore, ok := b.store.(metaAwareStore) + if !ok { + return + } + var rawScope json.RawMessage + if scope != nil { + data, err := json.Marshal(scope) + if err != nil { + log.Printf("session: encode session scope: %v", err) + return + } + rawScope = data + } + if err := metaStore.UpsertSessionMeta(context.Background(), sessionKey, rawScope, aliases); err != nil { + log.Printf("session: upsert session metadata: %v", err) + } +} + func (b *JSONLBackend) AddMessage(sessionKey, role, content string) { + sessionKey = b.resolveSessionKey(sessionKey) if err := b.store.AddMessage(context.Background(), sessionKey, role, content); err != nil { log.Printf("session: add message: %v", err) } } func (b *JSONLBackend) AddFullMessage(sessionKey string, msg providers.Message) { + sessionKey = b.resolveSessionKey(sessionKey) if err := b.store.AddFullMessage(context.Background(), sessionKey, msg); err != nil { log.Printf("session: add full message: %v", err) } } func (b *JSONLBackend) GetHistory(key string) []providers.Message { + key = b.resolveSessionKey(key) msgs, err := b.store.GetHistory(context.Background(), key) if err != nil { log.Printf("session: get history: %v", err) @@ -42,6 +101,7 @@ func (b *JSONLBackend) GetHistory(key string) []providers.Message { } func (b *JSONLBackend) GetSummary(key string) string { + key = b.resolveSessionKey(key) summary, err := b.store.GetSummary(context.Background(), key) if err != nil { log.Printf("session: get summary: %v", err) @@ -51,18 +111,21 @@ func (b *JSONLBackend) GetSummary(key string) string { } func (b *JSONLBackend) SetSummary(key, summary string) { + key = b.resolveSessionKey(key) if err := b.store.SetSummary(context.Background(), key, summary); err != nil { log.Printf("session: set summary: %v", err) } } func (b *JSONLBackend) SetHistory(key string, history []providers.Message) { + key = b.resolveSessionKey(key) if err := b.store.SetHistory(context.Background(), key, history); err != nil { log.Printf("session: set history: %v", err) } } func (b *JSONLBackend) TruncateHistory(key string, keepLast int) { + key = b.resolveSessionKey(key) if err := b.store.TruncateHistory(context.Background(), key, keepLast); err != nil { log.Printf("session: truncate history: %v", err) } @@ -72,6 +135,7 @@ func (b *JSONLBackend) TruncateHistory(key string, keepLast int) { // immediately, the data is already durable. Save runs compaction to reclaim // space from logically truncated messages (no-op when there are none). func (b *JSONLBackend) Save(key string) error { + key = b.resolveSessionKey(key) return b.store.Compact(context.Background(), key) } diff --git a/pkg/session/jsonl_backend_test.go b/pkg/session/jsonl_backend_test.go index 40fa019cb..32a69377b 100644 --- a/pkg/session/jsonl_backend_test.go +++ b/pkg/session/jsonl_backend_test.go @@ -177,3 +177,31 @@ func TestJSONLBackend_SummarizeFlow(t *testing.T) { t.Errorf("first message = %q, want %q", history[0].Content, "msg 16") } } + +func TestJSONLBackend_ResolveAliasAndPersistMetadata(t *testing.T) { + b := newBackend(t) + + b.EnsureSessionMetadata("canonical", &session.SessionScope{ + Version: session.ScopeVersionV1, + AgentID: "main", + Channel: "telegram", + Account: "default", + Dimensions: []string{"chat"}, + Values: map[string]string{ + "chat": "group:c1", + }, + }, []string{"legacy"}) + + if got := b.ResolveSessionKey("legacy"); got != "canonical" { + t.Fatalf("ResolveSessionKey() = %q, want %q", got, "canonical") + } + + b.AddMessage("legacy", "user", "hello through alias") + history := b.GetHistory("canonical") + if len(history) != 1 { + t.Fatalf("len(history) = %d, want 1", len(history)) + } + if history[0].Content != "hello through alias" { + t.Fatalf("history[0].Content = %q, want %q", history[0].Content, "hello through alias") + } +} diff --git a/web/backend/api/session.go b/web/backend/api/session.go index 42d451a05..d00fa84c8 100644 --- a/web/backend/api/session.go +++ b/web/backend/api/session.go @@ -13,7 +13,9 @@ import ( "time" "github.com/sipeed/picoclaw/pkg/config" + "github.com/sipeed/picoclaw/pkg/memory" "github.com/sipeed/picoclaw/pkg/providers" + "github.com/sipeed/picoclaw/pkg/session" ) // registerSessionRoutes binds session list and detail endpoints to the ServeMux. @@ -42,15 +44,6 @@ type sessionListItem struct { Updated string `json:"updated"` } -type sessionMetaFile struct { - Key string `json:"key"` - Summary string `json:"summary"` - Skip int `json:"skip"` - Count int `json:"count"` - CreatedAt time.Time `json:"created_at"` - UpdatedAt time.Time `json:"updated_at"` -} - // picoSessionPrefix is the key prefix used by the gateway's routing for Pico // channel sessions. The full key format is: // @@ -60,10 +53,9 @@ type sessionMetaFile struct { // // agent_main_pico_direct_pico_.json const ( - picoSessionPrefix = "agent:main:pico:direct:pico:" - sanitizedPicoSessionPrefix = "agent_main_pico_direct_pico_" - maxSessionJSONLLineSize = 10 * 1024 * 1024 // 10 MB - maxSessionTitleRunes = 60 + picoSessionPrefix = "agent:main:pico:direct:pico:" + maxSessionJSONLLineSize = 10 * 1024 * 1024 // 10 MB + maxSessionTitleRunes = 60 ) // extractPicoSessionID extracts the session UUID from a full session key. @@ -75,15 +67,11 @@ func extractPicoSessionID(key string) (string, bool) { return "", false } -func extractPicoSessionIDFromSanitizedKey(key string) (string, bool) { - if strings.HasPrefix(key, sanitizedPicoSessionPrefix) { - return strings.TrimPrefix(key, sanitizedPicoSessionPrefix), true - } - return "", false -} - func sanitizeSessionKey(key string) string { - return strings.ReplaceAll(key, ":", "_") + key = strings.ReplaceAll(key, ":", "_") + key = strings.ReplaceAll(key, "/", "_") + key = strings.ReplaceAll(key, "\\", "_") + return key } func (h *Handler) readLegacySession(dir, sessionID string) (sessionFile, error) { @@ -100,18 +88,18 @@ func (h *Handler) readLegacySession(dir, sessionID string) (sessionFile, error) return sess, nil } -func (h *Handler) readSessionMeta(path, sessionKey string) (sessionMetaFile, error) { +func (h *Handler) readSessionMeta(path, sessionKey string) (memory.SessionMeta, error) { data, err := os.ReadFile(path) if os.IsNotExist(err) { - return sessionMetaFile{Key: sessionKey}, nil + return memory.SessionMeta{Key: sessionKey}, nil } if err != nil { - return sessionMetaFile{}, err + return memory.SessionMeta{}, err } - var meta sessionMetaFile + var meta memory.SessionMeta if err := json.Unmarshal(data, &meta); err != nil { - return sessionMetaFile{}, err + return memory.SessionMeta{}, err } if meta.Key == "" { meta.Key = sessionKey @@ -154,8 +142,7 @@ func (h *Handler) readSessionMessages(path string, skip int) ([]providers.Messag return msgs, nil } -func (h *Handler) readJSONLSession(dir, sessionID string) (sessionFile, error) { - sessionKey := picoSessionPrefix + sessionID +func (h *Handler) readJSONLSession(dir, sessionKey string) (sessionFile, error) { base := filepath.Join(dir, sanitizeSessionKey(sessionKey)) jsonlPath := base + ".jsonl" metaPath := base + ".meta.json" @@ -192,6 +179,100 @@ func (h *Handler) readJSONLSession(dir, sessionID string) (sessionFile, error) { }, nil } +type picoJSONLSessionRef struct { + ID string + Key string +} + +func extractPicoSessionIDFromScope(scope session.SessionScope) (string, bool) { + if !strings.EqualFold(strings.TrimSpace(scope.Channel), "pico") { + return "", false + } + + candidates := []string{ + strings.TrimSpace(scope.Values["sender"]), + strings.TrimSpace(scope.Values["chat"]), + } + for _, candidate := range candidates { + if candidate == "" { + continue + } + if idx := strings.Index(candidate, "pico:"); idx >= 0 { + sessionID := strings.TrimSpace(candidate[idx+len("pico:"):]) + if sessionID != "" { + return sessionID, true + } + } + } + return "", false +} + +func sessionRefFromMeta(meta memory.SessionMeta) (picoJSONLSessionRef, bool) { + if sessionID, ok := extractPicoSessionID(meta.Key); ok { + return picoJSONLSessionRef{ID: sessionID, Key: meta.Key}, true + } + for _, alias := range meta.Aliases { + if sessionID, ok := extractPicoSessionID(alias); ok { + return picoJSONLSessionRef{ID: sessionID, Key: meta.Key}, true + } + } + if len(meta.Scope) == 0 { + return picoJSONLSessionRef{}, false + } + var scope session.SessionScope + if err := json.Unmarshal(meta.Scope, &scope); err != nil { + return picoJSONLSessionRef{}, false + } + sessionID, ok := extractPicoSessionIDFromScope(scope) + if !ok { + return picoJSONLSessionRef{}, false + } + return picoJSONLSessionRef{ID: sessionID, Key: meta.Key}, true +} + +func (h *Handler) findPicoJSONLSessions(dir string) ([]picoJSONLSessionRef, error) { + entries, err := os.ReadDir(dir) + if err != nil { + return nil, err + } + + refs := make([]picoJSONLSessionRef, 0) + seen := make(map[string]struct{}) + for _, entry := range entries { + if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".meta.json") { + continue + } + metaPath := filepath.Join(dir, entry.Name()) + meta, err := h.readSessionMeta(metaPath, "") + if err != nil { + continue + } + ref, ok := sessionRefFromMeta(meta) + if !ok || ref.Key == "" || ref.ID == "" { + continue + } + if _, exists := seen[ref.ID]; exists { + continue + } + seen[ref.ID] = struct{}{} + refs = append(refs, ref) + } + return refs, nil +} + +func (h *Handler) findPicoJSONLSession(dir, sessionID string) (picoJSONLSessionRef, error) { + refs, err := h.findPicoJSONLSessions(dir) + if err != nil { + return picoJSONLSessionRef{}, err + } + for _, ref := range refs { + if ref.ID == sessionID { + return ref, nil + } + } + return picoJSONLSessionRef{}, os.ErrNotExist +} + func buildSessionListItem(sessionID string, sess sessionFile) sessionListItem { preview := "" for _, msg := range sess.Messages { @@ -295,66 +376,45 @@ func (h *Handler) handleListSessions(w http.ResponseWriter, r *http.Request) { items := []sessionListItem{} seen := make(map[string]struct{}) + if refs, findErr := h.findPicoJSONLSessions(dir); findErr == nil { + for _, ref := range refs { + sess, loadErr := h.readJSONLSession(dir, ref.Key) + if loadErr != nil || isEmptySession(sess) { + continue + } + seen[ref.ID] = struct{}{} + items = append(items, buildSessionListItem(ref.ID, sess)) + } + } + for _, entry := range entries { if entry.IsDir() { continue } - name := entry.Name() - var ( - sessionID string - sess sessionFile - loadErr error - ok bool - ) - - switch { - case strings.HasSuffix(name, ".jsonl"): - sessionID, ok = extractPicoSessionIDFromSanitizedKey(strings.TrimSuffix(name, ".jsonl")) - if !ok { - continue - } - sess, loadErr = h.readJSONLSession(dir, sessionID) - if loadErr == nil && isEmptySession(sess) { - continue - } - case strings.HasSuffix(name, ".meta.json"): - continue - case filepath.Ext(name) == ".json": - base := strings.TrimSuffix(name, ".json") - if _, statErr := os.Stat(filepath.Join(dir, base+".jsonl")); statErr == nil { - if jsonlSessionID, found := extractPicoSessionIDFromSanitizedKey(base); found { - if jsonlSess, jsonlErr := h.readJSONLSession( - dir, - jsonlSessionID, - ); jsonlErr == nil && - !isEmptySession(jsonlSess) { - continue - } - } - } - data, err := os.ReadFile(filepath.Join(dir, name)) - if err != nil { - continue - } - if err := json.Unmarshal(data, &sess); err != nil { - continue - } - if isEmptySession(sess) { - continue - } - sessionID, ok = extractPicoSessionID(sess.Key) - if !ok { - continue - } - if _, exists := seen[sessionID]; exists { - continue - } - default: + if strings.HasSuffix(name, ".meta.json") || filepath.Ext(name) != ".json" { continue } - if loadErr != nil { + base := strings.TrimSuffix(name, ".json") + if _, statErr := os.Stat(filepath.Join(dir, base+".jsonl")); statErr == nil { + continue + } + + data, err := os.ReadFile(filepath.Join(dir, name)) + if err != nil { + continue + } + + var sess sessionFile + if err := json.Unmarshal(data, &sess); err != nil { + continue + } + if isEmptySession(sess) { + continue + } + sessionID, ok := extractPicoSessionID(sess.Key) + if !ok { continue } if _, exists := seen[sessionID]; exists { @@ -416,7 +476,12 @@ func (h *Handler) handleGetSession(w http.ResponseWriter, r *http.Request) { return } - sess, err := h.readJSONLSession(dir, sessionID) + ref, refErr := h.findPicoJSONLSession(dir, sessionID) + var sess sessionFile + err = refErr + if refErr == nil { + sess, err = h.readJSONLSession(dir, ref.Key) + } if err == nil && isEmptySession(sess) { err = os.ErrNotExist } @@ -480,20 +545,28 @@ func (h *Handler) handleDeleteSession(w http.ResponseWriter, r *http.Request) { return } - base := filepath.Join(dir, sanitizeSessionKey(picoSessionPrefix+sessionID)) - jsonlPath := base + ".jsonl" - metaPath := base + ".meta.json" - legacyPath := base + ".json" - removed := false - for _, path := range []string{jsonlPath, metaPath, legacyPath} { - if err := os.Remove(path); err != nil { - if os.IsNotExist(err) { - continue + if ref, err := h.findPicoJSONLSession(dir, sessionID); err == nil { + base := filepath.Join(dir, sanitizeSessionKey(ref.Key)) + for _, path := range []string{base + ".jsonl", base + ".meta.json"} { + if err := os.Remove(path); err != nil { + if os.IsNotExist(err) { + continue + } + http.Error(w, "failed to delete session", http.StatusInternalServerError) + return } + removed = true + } + } + + legacyPath := filepath.Join(dir, sanitizeSessionKey(picoSessionPrefix+sessionID)+".json") + if err := os.Remove(legacyPath); err != nil { + if !os.IsNotExist(err) { http.Error(w, "failed to delete session", http.StatusInternalServerError) return } + } else { removed = true } diff --git a/web/backend/api/session_test.go b/web/backend/api/session_test.go index 21ef5b5b8..eeb477c66 100644 --- a/web/backend/api/session_test.go +++ b/web/backend/api/session_test.go @@ -215,6 +215,83 @@ func TestHandleGetSession_JSONLStorage(t *testing.T) { } } +func TestHandleSessions_JSONLScopeDiscovery(t *testing.T) { + configPath, cleanup := setupOAuthTestEnv(t) + defer cleanup() + + dir := sessionsTestDir(t, configPath) + store, err := memory.NewJSONLStore(dir) + if err != nil { + t.Fatalf("NewJSONLStore() error = %v", err) + } + + sessionKey := "sk_v1_scope_discovery" + addErr := store.AddFullMessage(nil, sessionKey, providers.Message{ + Role: "user", + Content: "scope discovered session", + }) + if addErr != nil { + t.Fatalf("AddFullMessage() error = %v", addErr) + } + summaryErr := store.SetSummary(nil, sessionKey, "scope summary") + if summaryErr != nil { + t.Fatalf("SetSummary() error = %v", summaryErr) + } + + scopeData, err := json.Marshal(session.SessionScope{ + Version: session.ScopeVersionV1, + AgentID: "main", + Channel: "pico", + Account: "default", + Dimensions: []string{"sender"}, + Values: map[string]string{ + "sender": "pico:scope-jsonl", + }, + }) + if err != nil { + t.Fatalf("Marshal(scope) error = %v", err) + } + if err := store.UpsertSessionMeta(nil, sessionKey, scopeData, nil); err != nil { + t.Fatalf("UpsertSessionMeta() error = %v", err) + } + + h := NewHandler(configPath) + mux := http.NewServeMux() + h.RegisterRoutes(mux) + + listRec := httptest.NewRecorder() + listReq := httptest.NewRequest(http.MethodGet, "/api/sessions", nil) + mux.ServeHTTP(listRec, listReq) + if listRec.Code != http.StatusOK { + t.Fatalf("list status = %d, want %d, body=%s", listRec.Code, http.StatusOK, listRec.Body.String()) + } + + var items []sessionListItem + if err := json.Unmarshal(listRec.Body.Bytes(), &items); err != nil { + t.Fatalf("Unmarshal(list) error = %v", err) + } + if len(items) != 1 { + t.Fatalf("len(items) = %d, want 1", len(items)) + } + if items[0].ID != "scope-jsonl" { + t.Fatalf("items[0].ID = %q, want %q", items[0].ID, "scope-jsonl") + } + + detailRec := httptest.NewRecorder() + detailReq := httptest.NewRequest(http.MethodGet, "/api/sessions/scope-jsonl", nil) + mux.ServeHTTP(detailRec, detailReq) + if detailRec.Code != http.StatusOK { + t.Fatalf("detail status = %d, want %d, body=%s", detailRec.Code, http.StatusOK, detailRec.Body.String()) + } + + deleteRec := httptest.NewRecorder() + deleteReq := httptest.NewRequest(http.MethodDelete, "/api/sessions/scope-jsonl", nil) + mux.ServeHTTP(deleteRec, deleteReq) + if deleteRec.Code != http.StatusNoContent { + t.Fatalf("delete status = %d, want %d, body=%s", deleteRec.Code, http.StatusNoContent, deleteRec.Body.String()) + } +} + func TestHandleDeleteSession_JSONLStorage(t *testing.T) { configPath, cleanup := setupOAuthTestEnv(t) defer cleanup() From ca9652e120446938f1a7a516a476dd5368aad184 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 17:19:50 +0800 Subject: [PATCH 011/174] refactor(session): replace dm scope with dimensions policy --- pkg/agent/eventbus_test.go | 2 +- pkg/agent/hooks_test.go | 2 +- pkg/agent/loop.go | 18 +-- pkg/agent/loop_test.go | 10 +- pkg/agent/steering.go | 22 ++++ pkg/agent/steering_test.go | 59 +++++++++- pkg/agent/turn_context.go | 2 +- pkg/config/config.go | 12 +- pkg/config/config_test.go | 14 +-- pkg/config/defaults.go | 2 +- pkg/memory/jsonl.go | 29 +++-- pkg/memory/jsonl_test.go | 26 ++++ pkg/routing/route.go | 36 ++++-- pkg/routing/route_test.go | 6 +- pkg/routing/session_key.go | 13 ++ pkg/session/allocator.go | 189 +++++++++++++++++++++--------- pkg/session/allocator_test.go | 79 +++++++++---- pkg/session/jsonl_backend.go | 81 ++++++++++++- pkg/session/jsonl_backend_test.go | 38 +++++- pkg/session/key.go | 52 ++++++++ 20 files changed, 568 insertions(+), 124 deletions(-) create mode 100644 pkg/session/key.go diff --git a/pkg/agent/eventbus_test.go b/pkg/agent/eventbus_test.go index 6a75ab8d9..574d7bbcc 100644 --- a/pkg/agent/eventbus_test.go +++ b/pkg/agent/eventbus_test.go @@ -149,7 +149,7 @@ func TestAgentLoop_EmitsMinimalTurnEvents(t *testing.T) { Channel: "cli", AccountID: routing.DefaultAccountID, SessionPolicy: routing.SessionPolicy{ - DMScope: routing.DMScopePerPeer, + Dimensions: []string{"sender"}, }, MatchedBy: "default", }, diff --git a/pkg/agent/hooks_test.go b/pkg/agent/hooks_test.go index 3287a2a1d..6f61da65a 100644 --- a/pkg/agent/hooks_test.go +++ b/pkg/agent/hooks_test.go @@ -172,7 +172,7 @@ func TestAgentLoop_Hooks_ObserverAndLLMInterceptor(t *testing.T) { Channel: "cli", AccountID: routing.DefaultAccountID, SessionPolicy: routing.SessionPolicy{ - DMScope: routing.DMScopePerPeer, + Dimensions: []string{"sender"}, }, MatchedBy: "default", }, diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go index ef4680e45..70827598a 100644 --- a/pkg/agent/loop.go +++ b/pkg/agent/loop.go @@ -108,6 +108,7 @@ const ( toolLimitResponse = "I've reached `max_tool_iterations` without a final response. Increase `max_tool_iterations` in config.json if this task needs more tool steps." handledToolResponseSummary = "Requested output delivered via tool attachment." sessionKeyAgentPrefix = "agent:" + sessionKeyOpaquePrefix = "sk_" metadataKeyAccountID = "account_id" metadataKeyGuildID = "guild_id" metadataKeyTeamID = "team_id" @@ -1022,8 +1023,8 @@ func appendEventContextFields(fields map[string]any, turnCtx *TurnContext) { if route.MatchedBy != "" { fields["route_matched_by"] = route.MatchedBy } - if route.SessionPolicy.DMScope != "" { - fields["route_dm_scope"] = string(route.SessionPolicy.DMScope) + if len(route.SessionPolicy.Dimensions) > 0 { + fields["route_dimensions"] = strings.Join(route.SessionPolicy.Dimensions, ",") } if count := len(route.SessionPolicy.IdentityLinks); count > 0 { fields["route_identity_link_count"] = count @@ -1476,7 +1477,7 @@ func (al *AgentLoop) processMessage(ctx context.Context, msg bus.InboundMessage) opts := processOptions{ SessionKey: sessionKey, - SessionAliases: buildSessionAliases(sessionKey, allocation.SessionKey, msg.SessionKey), + SessionAliases: buildSessionAliases(sessionKey, append(allocation.SessionAliases, msg.SessionKey)...), Channel: msg.Channel, ChatID: msg.ChatID, MessageID: msg.MessageID, @@ -1543,12 +1544,17 @@ func normalizedInboundContext(msg bus.InboundMessage) bus.InboundContext { } func resolveScopeKey(routeSessionKey, msgSessionKey string) string { - if msgSessionKey != "" && strings.HasPrefix(msgSessionKey, sessionKeyAgentPrefix) { + if isExplicitSessionKey(msgSessionKey) { return msgSessionKey } return routeSessionKey } +func isExplicitSessionKey(sessionKey string) bool { + sessionKey = strings.TrimSpace(strings.ToLower(sessionKey)) + return strings.HasPrefix(sessionKey, sessionKeyAgentPrefix) || strings.HasPrefix(sessionKey, sessionKeyOpaquePrefix) +} + func buildSessionAliases(canonicalKey string, keys ...string) []string { if len(keys) == 0 { return nil @@ -1589,9 +1595,7 @@ func ensureSessionMetadata(store session.SessionStore, key string, scope *sessio func (al *AgentLoop) allocateRouteSession(route routing.ResolvedRoute, msg bus.InboundMessage) session.Allocation { return session.AllocateRouteSession(session.AllocationInput{ AgentID: route.AgentID, - Channel: route.Channel, - AccountID: route.AccountID, - Peer: extractPeer(msg), + Context: normalizedInboundContext(msg), SessionPolicy: route.SessionPolicy, }) } diff --git a/pkg/agent/loop_test.go b/pkg/agent/loop_test.go index dbc1b674b..3efb7ddfd 100644 --- a/pkg/agent/loop_test.go +++ b/pkg/agent/loop_test.go @@ -796,7 +796,7 @@ func TestAppendEventContextFields_IncludesInboundRouteAndScope(t *testing.T) { AccountID: "workspace-a", MatchedBy: "binding.team", SessionPolicy: routing.SessionPolicy{ - DMScope: routing.DMScopePerChannelPeer, + Dimensions: []string{"chat", "sender"}, IdentityLinks: map[string][]string{ "canonical-user": {"slack:U123"}, }, @@ -824,8 +824,8 @@ func TestAppendEventContextFields_IncludesInboundRouteAndScope(t *testing.T) { if fields["route_matched_by"] != "binding.team" { t.Fatalf("route_matched_by = %v, want binding.team", fields["route_matched_by"]) } - if fields["route_dm_scope"] != string(routing.DMScopePerChannelPeer) { - t.Fatalf("route_dm_scope = %v, want %q", fields["route_dm_scope"], routing.DMScopePerChannelPeer) + if fields["route_dimensions"] != "chat,sender" { + t.Fatalf("route_dimensions = %v, want chat,sender", fields["route_dimensions"]) } if fields["route_identity_link_count"] != 1 { t.Fatalf("route_identity_link_count = %v, want 1", fields["route_identity_link_count"]) @@ -865,7 +865,7 @@ func TestResolveMessageRoute_UsesInboundContextAccountAndSpace(t *testing.T) { }, }, Session: config.SessionConfig{ - DMScope: "per-peer", + Dimensions: []string{"sender"}, }, } @@ -1600,7 +1600,7 @@ func TestProcessMessage_CommandOutcomes(t *testing.T) { }, }, Session: config.SessionConfig{ - DMScope: "per-channel-peer", + Dimensions: []string{"chat"}, }, } diff --git a/pkg/agent/steering.go b/pkg/agent/steering.go index ad6613e8c..b5cf049b3 100644 --- a/pkg/agent/steering.go +++ b/pkg/agent/steering.go @@ -9,6 +9,7 @@ import ( "github.com/sipeed/picoclaw/pkg/logger" "github.com/sipeed/picoclaw/pkg/providers" "github.com/sipeed/picoclaw/pkg/routing" + "github.com/sipeed/picoclaw/pkg/session" "github.com/sipeed/picoclaw/pkg/tools" ) @@ -310,6 +311,27 @@ func (al *AgentLoop) agentForSession(sessionKey string) *AgentInstance { return nil } + for _, agentID := range registry.ListAgentIDs() { + agent, ok := registry.GetAgent(agentID) + if !ok || agent == nil { + continue + } + scopeReader, ok := agent.Sessions.(interface { + GetSessionScope(sessionKey string) *session.SessionScope + }) + if !ok { + continue + } + scope := scopeReader.GetSessionScope(sessionKey) + if scope == nil || strings.TrimSpace(scope.AgentID) == "" { + continue + } + if scopedAgent, ok := registry.GetAgent(scope.AgentID); ok { + return scopedAgent + } + return agent + } + if parsed := routing.ParseAgentSessionKey(sessionKey); parsed != nil { if agent, ok := registry.GetAgent(parsed.AgentID); ok { return agent diff --git a/pkg/agent/steering_test.go b/pkg/agent/steering_test.go index 75ba9861d..b67ec006c 100644 --- a/pkg/agent/steering_test.go +++ b/pkg/agent/steering_test.go @@ -17,6 +17,7 @@ import ( "github.com/sipeed/picoclaw/pkg/media" "github.com/sipeed/picoclaw/pkg/providers" "github.com/sipeed/picoclaw/pkg/routing" + "github.com/sipeed/picoclaw/pkg/session" "github.com/sipeed/picoclaw/pkg/tools" ) @@ -357,7 +358,7 @@ func TestDrainBusToSteering_RequeuesDifferentScopeMessage(t *testing.T) { }, }, Session: config.SessionConfig{ - DMScope: "per-peer", + Dimensions: []string{"sender"}, }, } @@ -1013,6 +1014,62 @@ func TestAgentLoop_Steering_DirectResponseContinuesWithQueuedMessage(t *testing. } } +func TestAgentLoop_AgentForSession_UsesStoredScopeMetadata(t *testing.T) { + tmpDir, err := os.MkdirTemp("", "agent-test-*") + if err != nil { + t.Fatalf("Failed to create temp dir: %v", err) + } + defer os.RemoveAll(tmpDir) + + cfg := &config.Config{ + Agents: config.AgentsConfig{ + Defaults: config.AgentDefaults{ + Workspace: tmpDir, + ModelName: "test-model", + MaxTokens: 4096, + MaxToolIterations: 10, + }, + List: []config.AgentConfig{ + {ID: "sales", Default: true}, + {ID: "support"}, + }, + }, + } + + al := NewAgentLoop(cfg, bus.NewMessageBus(), &mockProvider{}) + support, ok := al.registry.GetAgent("support") + if !ok || support == nil { + t.Fatal("expected support agent") + } + + metaStore, ok := support.Sessions.(session.MetadataAwareSessionStore) + if !ok { + t.Fatal("support session store does not support metadata") + } + + alias := "agent:support:slack:channel:c001" + key := session.BuildOpaqueSessionKey(alias) + scope := &session.SessionScope{ + Version: session.ScopeVersionV1, + AgentID: "support", + Channel: "slack", + Account: "default", + Dimensions: []string{"chat"}, + Values: map[string]string{ + "chat": "channel:c001", + }, + } + metaStore.EnsureSessionMetadata(key, scope, []string{alias}) + + got := al.agentForSession(key) + if got == nil { + t.Fatal("agentForSession() returned nil") + } + if got.ID != "support" { + t.Fatalf("agentForSession() = %q, want %q", got.ID, "support") + } +} + func TestAgentLoop_Continue_PreservesSteeringMedia(t *testing.T) { tmpDir, err := os.MkdirTemp("", "agent-test-*") if err != nil { diff --git a/pkg/agent/turn_context.go b/pkg/agent/turn_context.go index 95ed5a0f3..8913993aa 100644 --- a/pkg/agent/turn_context.go +++ b/pkg/agent/turn_context.go @@ -72,7 +72,7 @@ func cloneResolvedRoute(route *routing.ResolvedRoute) *routing.ResolvedRoute { } cloned := *route cloned.SessionPolicy = routing.SessionPolicy{ - DMScope: route.SessionPolicy.DMScope, + Dimensions: append([]string(nil), route.SessionPolicy.Dimensions...), IdentityLinks: cloneIdentityLinks(route.SessionPolicy.IdentityLinks), } return &cloned diff --git a/pkg/config/config.go b/pkg/config/config.go index 397cd4ab8..10eb07339 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -109,9 +109,12 @@ func (c *Config) MarshalJSON() ([]byte, error) { Alias: (*Alias)(c), } - // Only include session if not empty - if c.Session.DMScope != "" || len(c.Session.IdentityLinks) > 0 { - aux.Session = &c.Session + // Only include session if not empty. Deprecated dm_scope is intentionally + // omitted so persisted configs converge on dimensions-based session policy. + if len(c.Session.Dimensions) > 0 || len(c.Session.IdentityLinks) > 0 { + sessionCfg := c.Session + sessionCfg.DMScope = "" + aux.Session = &sessionCfg } return json.Marshal(aux) @@ -195,7 +198,8 @@ type AgentBinding struct { } type SessionConfig struct { - DMScope string `json:"dm_scope,omitempty"` + Dimensions []string `json:"dimensions,omitempty"` + DMScope string `json:"dm_scope,omitempty"` // Deprecated: ignored by the new session policy path. IdentityLinks map[string][]string `json:"identity_links,omitempty"` } diff --git a/pkg/config/config_test.go b/pkg/config/config_test.go index 278dfa43a..e8ebf1cfe 100644 --- a/pkg/config/config_test.go +++ b/pkg/config/config_test.go @@ -137,7 +137,7 @@ func TestAgentConfig_FullParse(t *testing.T) { } ], "session": { - "dm_scope": "per-peer", + "dimensions": ["sender"], "identity_links": { "john": ["telegram:123", "discord:john#1234"] } @@ -186,8 +186,8 @@ func TestAgentConfig_FullParse(t *testing.T) { t.Errorf("binding.Match.Peer = %+v", binding.Match.Peer) } - if cfg.Session.DMScope != "per-peer" { - t.Errorf("Session.DMScope = %q", cfg.Session.DMScope) + if len(cfg.Session.Dimensions) != 1 || cfg.Session.Dimensions[0] != "sender" { + t.Errorf("Session.Dimensions = %v", cfg.Session.Dimensions) } if len(cfg.Session.IdentityLinks) != 1 { t.Errorf("Session.IdentityLinks = %v", cfg.Session.IdentityLinks) @@ -758,7 +758,7 @@ func TestLoadConfig_HooksProcessConfig(t *testing.T) { } } -// TestDefaultConfig_DMScope verifies the default dm_scope value +// TestDefaultConfig_SessionDimensions verifies the default session dimensions // TestDefaultConfig_SummarizationThresholds verifies summarization defaults func TestDefaultConfig_SummarizationThresholds(t *testing.T) { cfg := DefaultConfig() @@ -771,11 +771,11 @@ func TestDefaultConfig_SummarizationThresholds(t *testing.T) { } } -func TestDefaultConfig_DMScope(t *testing.T) { +func TestDefaultConfig_SessionDimensions(t *testing.T) { cfg := DefaultConfig() - if cfg.Session.DMScope != "per-channel-peer" { - t.Errorf("Session.DMScope = %q, want 'per-channel-peer'", cfg.Session.DMScope) + if len(cfg.Session.Dimensions) != 1 || cfg.Session.Dimensions[0] != "chat" { + t.Errorf("Session.Dimensions = %v, want [chat]", cfg.Session.Dimensions) } } diff --git a/pkg/config/defaults.go b/pkg/config/defaults.go index c3845e3e2..58cd05088 100644 --- a/pkg/config/defaults.go +++ b/pkg/config/defaults.go @@ -37,7 +37,7 @@ func DefaultConfig() *Config { }, Bindings: []AgentBinding{}, Session: SessionConfig{ - DMScope: "per-channel-peer", + Dimensions: []string{"chat"}, }, Channels: ChannelsConfig{ WhatsApp: WhatsAppConfig{ diff --git a/pkg/memory/jsonl.go b/pkg/memory/jsonl.go index 70c55329f..7e2c6b892 100644 --- a/pkg/memory/jsonl.go +++ b/pkg/memory/jsonl.go @@ -230,9 +230,6 @@ func (s *JSONLStore) ResolveSessionKey(_ context.Context, sessionKey string) (st if sessionKey == "" { return "", false, nil } - if s.sessionExists(sessionKey) { - return sessionKey, true, nil - } entries, err := os.ReadDir(s.dir) if err != nil { @@ -254,16 +251,34 @@ func (s *JSONLStore) ResolveSessionKey(_ context.Context, sessionKey string) (st if meta.Key == "" { continue } - if meta.Key == sessionKey { - return meta.Key, true, nil - } for _, alias := range meta.Aliases { - if alias == sessionKey { + if alias == sessionKey && meta.Key != sessionKey { return meta.Key, true, nil } } } + for _, entry := range entries { + if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".meta.json") { + continue + } + data, readErr := os.ReadFile(filepath.Join(s.dir, entry.Name())) + if readErr != nil { + return "", false, fmt.Errorf("memory: read meta: %w", readErr) + } + var meta SessionMeta + if err := json.Unmarshal(data, &meta); err != nil { + return "", false, fmt.Errorf("memory: decode meta: %w", err) + } + if meta.Key == sessionKey { + return meta.Key, true, nil + } + } + + if s.sessionExists(sessionKey) { + return sessionKey, true, nil + } + return "", false, nil } diff --git a/pkg/memory/jsonl_test.go b/pkg/memory/jsonl_test.go index ef739e49b..71ce8d866 100644 --- a/pkg/memory/jsonl_test.go +++ b/pkg/memory/jsonl_test.go @@ -296,6 +296,32 @@ func TestResolveSessionKeyByAlias(t *testing.T) { } } +func TestResolveSessionKeyByAlias_PrefersMetadataOverLegacyFile(t *testing.T) { + store := newTestStore(t) + ctx := context.Background() + + if err := store.AddMessage(ctx, "legacy:key", "user", "legacy"); err != nil { + t.Fatalf("AddMessage(legacy) error = %v", err) + } + if err := store.AddMessage(ctx, "canonical", "user", "canonical"); err != nil { + t.Fatalf("AddMessage(canonical) error = %v", err) + } + if err := store.UpsertSessionMeta(ctx, "canonical", nil, []string{"legacy:key"}); err != nil { + t.Fatalf("UpsertSessionMeta() error = %v", err) + } + + resolved, found, err := store.ResolveSessionKey(ctx, "legacy:key") + if err != nil { + t.Fatalf("ResolveSessionKey() error = %v", err) + } + if !found { + t.Fatal("ResolveSessionKey() did not find alias") + } + if resolved != "canonical" { + t.Fatalf("resolved = %q, want %q", resolved, "canonical") + } +} + func TestTruncateHistory_KeepLast(t *testing.T) { store := newTestStore(t) ctx := context.Background() diff --git a/pkg/routing/route.go b/pkg/routing/route.go index 494aefabb..e5a000067 100644 --- a/pkg/routing/route.go +++ b/pkg/routing/route.go @@ -17,10 +17,8 @@ type RouteInput struct { } // SessionPolicy describes how a routed message should be mapped to a session. -// The current implementation preserves the legacy dm_scope and identity_link -// semantics while moving session-key construction out of the router. type SessionPolicy struct { - DMScope DMScope + Dimensions []string IdentityLinks map[string][]string } @@ -246,16 +244,38 @@ func (r *RouteResolver) resolveDefaultAgentID() string { } func (r *RouteResolver) sessionPolicy() SessionPolicy { - dmScope := DMScope(r.cfg.Session.DMScope) - if dmScope == "" { - dmScope = DMScopeMain - } return SessionPolicy{ - DMScope: dmScope, + Dimensions: normalizeSessionDimensions(r.cfg.Session.Dimensions), IdentityLinks: cloneIdentityLinks(r.cfg.Session.IdentityLinks), } } +func normalizeSessionDimensions(dimensions []string) []string { + if len(dimensions) == 0 { + return nil + } + + normalized := make([]string, 0, len(dimensions)) + seen := make(map[string]struct{}, len(dimensions)) + for _, dimension := range dimensions { + dimension = strings.ToLower(strings.TrimSpace(dimension)) + switch dimension { + case "space", "chat", "topic", "sender": + default: + continue + } + if _, ok := seen[dimension]; ok { + continue + } + seen[dimension] = struct{}{} + normalized = append(normalized, dimension) + } + if len(normalized) == 0 { + return nil + } + return normalized +} + func cloneIdentityLinks(src map[string][]string) map[string][]string { if len(src) == 0 { return nil diff --git a/pkg/routing/route_test.go b/pkg/routing/route_test.go index ab1a7a4e2..3397bd8e8 100644 --- a/pkg/routing/route_test.go +++ b/pkg/routing/route_test.go @@ -17,7 +17,7 @@ func testConfig(agents []config.AgentConfig, bindings []config.AgentBinding) *co }, Bindings: bindings, Session: config.SessionConfig{ - DMScope: "per-peer", + Dimensions: []string{"sender"}, }, } } @@ -37,8 +37,8 @@ func TestResolveRoute_DefaultAgent_NoBindings(t *testing.T) { if route.MatchedBy != "default" { t.Errorf("MatchedBy = %q, want 'default'", route.MatchedBy) } - if route.SessionPolicy.DMScope != DMScopePerPeer { - t.Errorf("SessionPolicy.DMScope = %q, want %q", route.SessionPolicy.DMScope, DMScopePerPeer) + if len(route.SessionPolicy.Dimensions) != 1 || route.SessionPolicy.Dimensions[0] != "sender" { + t.Errorf("SessionPolicy.Dimensions = %v, want [sender]", route.SessionPolicy.Dimensions) } if route.SessionPolicy.IdentityLinks != nil { t.Errorf("SessionPolicy.IdentityLinks = %v, want nil", route.SessionPolicy.IdentityLinks) diff --git a/pkg/routing/session_key.go b/pkg/routing/session_key.go index 17b62f4b7..cc3ce43f3 100644 --- a/pkg/routing/session_key.go +++ b/pkg/routing/session_key.go @@ -112,6 +112,19 @@ func CanonicalSessionPeerID( return strings.ToLower(normalizedPeerID) } +// CanonicalSessionIdentityID collapses an identity using identity_links when +// possible, then returns a normalized lowercase identifier. +func CanonicalSessionIdentityID(channel, rawID string, identityLinks map[string][]string) string { + normalizedID := strings.TrimSpace(rawID) + if normalizedID == "" { + return "" + } + if linked := resolveLinkedPeerID(identityLinks, channel, normalizedID); linked != "" { + normalizedID = linked + } + return strings.ToLower(normalizedID) +} + // ParseAgentSessionKey extracts agentId and rest from "agent::". func ParseAgentSessionKey(sessionKey string) *ParsedSessionKey { raw := strings.TrimSpace(sessionKey) diff --git a/pkg/session/allocator.go b/pkg/session/allocator.go index a3b8e075d..6bf678deb 100644 --- a/pkg/session/allocator.go +++ b/pkg/session/allocator.go @@ -4,6 +4,7 @@ import ( "fmt" "strings" + "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/routing" ) @@ -13,85 +14,167 @@ import ( type Allocation struct { Scope SessionScope SessionKey string + SessionAliases []string MainSessionKey string + MainAliases []string } // AllocationInput contains the routing result and peer context needed to // derive the session keys for a turn. type AllocationInput struct { AgentID string - Channel string - AccountID string - Peer *routing.RoutePeer + Context bus.InboundContext SessionPolicy routing.SessionPolicy } -// AllocateRouteSession maps a route decision onto the current legacy -// agent-scoped session-key format. +// AllocateRouteSession maps a route decision onto a structured scope and the +// current opaque session-key format. func AllocateRouteSession(input AllocationInput) Allocation { scope := buildSessionScope(input) - sessionKey := strings.ToLower(routing.BuildAgentPeerSessionKey(routing.SessionKeyParams{ - AgentID: input.AgentID, - Channel: input.Channel, - AccountID: input.AccountID, - Peer: input.Peer, - DMScope: input.SessionPolicy.DMScope, - IdentityLinks: input.SessionPolicy.IdentityLinks, - })) - mainSessionKey := strings.ToLower(routing.BuildAgentMainSessionKey(input.AgentID)) + legacySessionAliases := buildLegacySessionAliases(input) + legacyMainSessionKey := strings.ToLower(routing.BuildAgentMainSessionKey(input.AgentID)) return Allocation{ Scope: scope, - SessionKey: sessionKey, - MainSessionKey: mainSessionKey, + SessionKey: BuildSessionKey(scope), + SessionAliases: legacySessionAliases, + MainSessionKey: BuildOpaqueSessionKey(legacyMainSessionKey), + MainAliases: []string{legacyMainSessionKey}, } } func buildSessionScope(input AllocationInput) SessionScope { + inbound := input.Context scope := SessionScope{ Version: ScopeVersionV1, AgentID: routing.NormalizeAgentID(input.AgentID), - Channel: strings.ToLower(strings.TrimSpace(input.Channel)), - Account: routing.NormalizeAccountID(input.AccountID), + Channel: strings.ToLower(strings.TrimSpace(inbound.Channel)), + Account: routing.NormalizeAccountID(inbound.Account), + } + if scope.Channel == "" { + scope.Channel = "unknown" } - peer := input.Peer - if peer == nil { - peer = &routing.RoutePeer{Kind: "direct"} + dimensions := make([]string, 0, len(input.SessionPolicy.Dimensions)) + values := make(map[string]string, len(input.SessionPolicy.Dimensions)) + + for _, dimension := range input.SessionPolicy.Dimensions { + switch dimension { + case "space": + if spaceID := strings.TrimSpace(inbound.SpaceID); spaceID != "" { + spaceType := strings.ToLower(strings.TrimSpace(inbound.SpaceType)) + if spaceType == "" { + spaceType = "space" + } + dimensions = append(dimensions, "space") + values["space"] = fmt.Sprintf("%s:%s", spaceType, strings.ToLower(spaceID)) + } + case "chat": + chatID := strings.TrimSpace(inbound.ChatID) + if chatID == "" { + continue + } + chatType := strings.ToLower(strings.TrimSpace(inbound.ChatType)) + if chatType == "" { + chatType = "direct" + } + dimensions = append(dimensions, "chat") + values["chat"] = fmt.Sprintf("%s:%s", chatType, strings.ToLower(chatID)) + case "topic": + if topicID := strings.TrimSpace(inbound.TopicID); topicID != "" { + dimensions = append(dimensions, "topic") + values["topic"] = "topic:" + strings.ToLower(topicID) + } + case "sender": + senderID := routing.CanonicalSessionIdentityID( + inbound.Channel, + inbound.SenderID, + input.SessionPolicy.IdentityLinks, + ) + if senderID == "" { + continue + } + dimensions = append(dimensions, "sender") + values["sender"] = senderID + } } - peerKind := strings.ToLower(strings.TrimSpace(peer.Kind)) - if peerKind == "" { - peerKind = "direct" - } - - switch peerKind { - case "direct": - if input.SessionPolicy.DMScope == routing.DMScopeMain { - return scope - } - peerID := routing.CanonicalSessionPeerID( - input.Channel, - peer.ID, - input.SessionPolicy.DMScope, - input.SessionPolicy.IdentityLinks, - ) - if peerID == "" { - return scope - } - scope.Dimensions = []string{"sender"} - scope.Values = map[string]string{ - "sender": peerID, - } - default: - peerID := strings.ToLower(strings.TrimSpace(peer.ID)) - if peerID == "" { - peerID = "unknown" - } - scope.Dimensions = []string{"chat"} - scope.Values = map[string]string{ - "chat": fmt.Sprintf("%s:%s", peerKind, peerID), - } + if len(dimensions) > 0 { + scope.Dimensions = dimensions + scope.Values = values } return scope } + +func buildLegacySessionAliases(input AllocationInput) []string { + aliases := []string{strings.ToLower(routing.BuildAgentMainSessionKey(input.AgentID))} + inbound := input.Context + + if strings.EqualFold(strings.TrimSpace(inbound.ChatType), "direct") { + senderID := routing.CanonicalSessionIdentityID( + inbound.Channel, + inbound.SenderID, + input.SessionPolicy.IdentityLinks, + ) + if senderID == "" { + return uniqueAliases(aliases) + } + for _, dmScope := range []routing.DMScope{ + routing.DMScopePerPeer, + routing.DMScopePerChannelPeer, + routing.DMScopePerAccountChannelPeer, + } { + aliases = append(aliases, strings.ToLower(routing.BuildAgentPeerSessionKey(routing.SessionKeyParams{ + AgentID: input.AgentID, + Channel: inbound.Channel, + AccountID: inbound.Account, + Peer: &routing.RoutePeer{Kind: "direct", ID: senderID}, + DMScope: dmScope, + IdentityLinks: input.SessionPolicy.IdentityLinks, + }))) + } + return uniqueAliases(aliases) + } + + peerID := strings.TrimSpace(inbound.ChatID) + if peerID == "" { + return uniqueAliases(aliases) + } + if topicID := strings.TrimSpace(inbound.TopicID); topicID != "" { + peerID = peerID + "/" + topicID + } + aliases = append(aliases, strings.ToLower(routing.BuildAgentPeerSessionKey(routing.SessionKeyParams{ + AgentID: input.AgentID, + Channel: inbound.Channel, + AccountID: inbound.Account, + Peer: &routing.RoutePeer{ + Kind: strings.ToLower(strings.TrimSpace(inbound.ChatType)), + ID: peerID, + }, + }))) + + return uniqueAliases(aliases) +} + +func uniqueAliases(aliases []string) []string { + if len(aliases) == 0 { + return nil + } + normalized := make([]string, 0, len(aliases)) + seen := make(map[string]struct{}, len(aliases)) + for _, alias := range aliases { + alias = strings.TrimSpace(strings.ToLower(alias)) + if alias == "" { + continue + } + if _, ok := seen[alias]; ok { + continue + } + seen[alias] = struct{}{} + normalized = append(normalized, alias) + } + if len(normalized) == 0 { + return nil + } + return normalized +} diff --git a/pkg/session/allocator_test.go b/pkg/session/allocator_test.go index 5eb442e98..c688fe0bf 100644 --- a/pkg/session/allocator_test.go +++ b/pkg/session/allocator_test.go @@ -3,28 +3,36 @@ package session import ( "testing" + "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/routing" ) func TestAllocateRouteSession_PerPeerDM(t *testing.T) { allocation := AllocateRouteSession(AllocationInput{ - AgentID: "main", - Channel: "telegram", - AccountID: "default", - Peer: &routing.RoutePeer{ - Kind: "direct", - ID: "User123", + AgentID: "main", + Context: bus.InboundContext{ + Channel: "telegram", + Account: "default", + ChatID: "dm-123", + ChatType: "direct", + SenderID: "User123", }, SessionPolicy: routing.SessionPolicy{ - DMScope: routing.DMScopePerPeer, + Dimensions: []string{"sender"}, }, }) - if allocation.SessionKey != "agent:main:direct:user123" { - t.Fatalf("SessionKey = %q, want %q", allocation.SessionKey, "agent:main:direct:user123") + if allocation.SessionKey == "" || !IsOpaqueSessionKey(allocation.SessionKey) { + t.Fatalf("SessionKey = %q, want opaque session key", allocation.SessionKey) } - if allocation.MainSessionKey != "agent:main:main" { - t.Fatalf("MainSessionKey = %q, want %q", allocation.MainSessionKey, "agent:main:main") + if !containsAlias(allocation.SessionAliases, "agent:main:direct:user123") { + t.Fatalf("SessionAliases = %v, want to contain agent:main:direct:user123", allocation.SessionAliases) + } + if allocation.MainSessionKey == "" || !IsOpaqueSessionKey(allocation.MainSessionKey) { + t.Fatalf("MainSessionKey = %q, want opaque session key", allocation.MainSessionKey) + } + if len(allocation.MainAliases) != 1 || allocation.MainAliases[0] != "agent:main:main" { + t.Fatalf("MainAliases = %v, want [agent:main:main]", allocation.MainAliases) } if allocation.Scope.Version != ScopeVersionV1 { t.Fatalf("Scope.Version = %d, want %d", allocation.Scope.Version, ScopeVersionV1) @@ -39,23 +47,30 @@ func TestAllocateRouteSession_PerPeerDM(t *testing.T) { func TestAllocateRouteSession_GroupPeer(t *testing.T) { allocation := AllocateRouteSession(AllocationInput{ - AgentID: "main", - Channel: "slack", - AccountID: "workspace-a", - Peer: &routing.RoutePeer{ - Kind: "channel", - ID: "C001", + AgentID: "main", + Context: bus.InboundContext{ + Channel: "slack", + Account: "workspace-a", + ChatID: "C001", + ChatType: "channel", + SenderID: "U001", }, SessionPolicy: routing.SessionPolicy{ - DMScope: routing.DMScopePerAccountChannelPeer, + Dimensions: []string{"chat"}, }, }) - if allocation.SessionKey != "agent:main:slack:channel:c001" { - t.Fatalf("SessionKey = %q, want %q", allocation.SessionKey, "agent:main:slack:channel:c001") + if allocation.SessionKey == "" || !IsOpaqueSessionKey(allocation.SessionKey) { + t.Fatalf("SessionKey = %q, want opaque session key", allocation.SessionKey) } - if allocation.MainSessionKey != "agent:main:main" { - t.Fatalf("MainSessionKey = %q, want %q", allocation.MainSessionKey, "agent:main:main") + if !containsAlias(allocation.SessionAliases, "agent:main:slack:channel:c001") { + t.Fatalf("SessionAliases = %v, want to contain agent:main:slack:channel:c001", allocation.SessionAliases) + } + if allocation.MainSessionKey == "" || !IsOpaqueSessionKey(allocation.MainSessionKey) { + t.Fatalf("MainSessionKey = %q, want opaque session key", allocation.MainSessionKey) + } + if len(allocation.MainAliases) != 1 || allocation.MainAliases[0] != "agent:main:main" { + t.Fatalf("MainAliases = %v, want [agent:main:main]", allocation.MainAliases) } if len(allocation.Scope.Dimensions) != 1 || allocation.Scope.Dimensions[0] != "chat" { t.Fatalf("Scope.Dimensions = %v, want [chat]", allocation.Scope.Dimensions) @@ -64,3 +79,23 @@ func TestAllocateRouteSession_GroupPeer(t *testing.T) { t.Fatalf("Scope.Values[chat] = %q, want channel:c001", allocation.Scope.Values["chat"]) } } + +func TestBuildOpaqueSessionKey_IsStable(t *testing.T) { + first := BuildOpaqueSessionKey("agent:main:direct:user123") + second := BuildOpaqueSessionKey("agent:main:direct:user123") + if first != second { + t.Fatalf("BuildOpaqueSessionKey() mismatch: %q != %q", first, second) + } + if !IsOpaqueSessionKey(first) { + t.Fatalf("expected opaque session key, got %q", first) + } +} + +func containsAlias(aliases []string, want string) bool { + for _, alias := range aliases { + if alias == want { + return true + } + } + return false +} diff --git a/pkg/session/jsonl_backend.go b/pkg/session/jsonl_backend.go index 38a0c160e..caa18a624 100644 --- a/pkg/session/jsonl_backend.go +++ b/pkg/session/jsonl_backend.go @@ -4,6 +4,7 @@ import ( "context" "encoding/json" "log" + "strings" "github.com/sipeed/picoclaw/pkg/memory" "github.com/sipeed/picoclaw/pkg/providers" @@ -26,6 +27,7 @@ type metaAwareStore interface { type MetadataAwareSessionStore interface { EnsureSessionMetadata(sessionKey string, scope *SessionScope, aliases []string) ResolveSessionKey(sessionKey string) string + GetSessionScope(sessionKey string) *SessionScope } // NewJSONLBackend wraps a memory.Store for use as a SessionStore. @@ -62,6 +64,11 @@ func (b *JSONLBackend) EnsureSessionMetadata(sessionKey string, scope *SessionSc if !ok { return } + sessionKey = strings.TrimSpace(sessionKey) + if sessionKey == "" { + return + } + var rawScope json.RawMessage if scope != nil { data, err := json.Marshal(scope) @@ -71,9 +78,81 @@ func (b *JSONLBackend) EnsureSessionMetadata(sessionKey string, scope *SessionSc } rawScope = data } - if err := metaStore.UpsertSessionMeta(context.Background(), sessionKey, rawScope, aliases); err != nil { + ctx := context.Background() + if err := metaStore.UpsertSessionMeta(ctx, sessionKey, rawScope, aliases); err != nil { log.Printf("session: upsert session metadata: %v", err) + return } + + canonicalHistory, historyErr := b.store.GetHistory(ctx, sessionKey) + if historyErr != nil { + log.Printf("session: get canonical history: %v", historyErr) + return + } + canonicalSummary, summaryErr := b.store.GetSummary(ctx, sessionKey) + if summaryErr != nil { + log.Printf("session: get canonical summary: %v", summaryErr) + return + } + if len(canonicalHistory) > 0 || strings.TrimSpace(canonicalSummary) != "" { + return + } + + for _, alias := range aliases { + alias = strings.TrimSpace(alias) + if alias == "" || alias == sessionKey { + continue + } + aliasHistory, err := b.store.GetHistory(ctx, alias) + if err != nil { + log.Printf("session: get alias history: %v", err) + continue + } + aliasSummary, err := b.store.GetSummary(ctx, alias) + if err != nil { + log.Printf("session: get alias summary: %v", err) + continue + } + if len(aliasHistory) == 0 && strings.TrimSpace(aliasSummary) == "" { + continue + } + if err := b.store.SetHistory(ctx, sessionKey, aliasHistory); err != nil { + log.Printf("session: promote alias history: %v", err) + return + } + if strings.TrimSpace(aliasSummary) != "" { + if err := b.store.SetSummary(ctx, sessionKey, aliasSummary); err != nil { + log.Printf("session: promote alias summary: %v", err) + } + } + if err := metaStore.UpsertSessionMeta(ctx, sessionKey, rawScope, aliases); err != nil { + log.Printf("session: refresh session metadata after promotion: %v", err) + } + return + } +} + +// GetSessionScope reads structured scope metadata for a session key or alias. +func (b *JSONLBackend) GetSessionScope(sessionKey string) *SessionScope { + metaStore, ok := b.store.(metaAwareStore) + if !ok { + return nil + } + sessionKey = b.resolveSessionKey(sessionKey) + meta, err := metaStore.GetSessionMeta(context.Background(), sessionKey) + if err != nil { + log.Printf("session: get session metadata: %v", err) + return nil + } + if len(meta.Scope) == 0 { + return nil + } + var scope SessionScope + if err := json.Unmarshal(meta.Scope, &scope); err != nil { + log.Printf("session: decode session scope: %v", err) + return nil + } + return CloneScope(&scope) } func (b *JSONLBackend) AddMessage(sessionKey, role, content string) { diff --git a/pkg/session/jsonl_backend_test.go b/pkg/session/jsonl_backend_test.go index 32a69377b..411e3e8c5 100644 --- a/pkg/session/jsonl_backend_test.go +++ b/pkg/session/jsonl_backend_test.go @@ -181,7 +181,7 @@ func TestJSONLBackend_SummarizeFlow(t *testing.T) { func TestJSONLBackend_ResolveAliasAndPersistMetadata(t *testing.T) { b := newBackend(t) - b.EnsureSessionMetadata("canonical", &session.SessionScope{ + scope := &session.SessionScope{ Version: session.ScopeVersionV1, AgentID: "main", Channel: "telegram", @@ -190,7 +190,8 @@ func TestJSONLBackend_ResolveAliasAndPersistMetadata(t *testing.T) { Values: map[string]string{ "chat": "group:c1", }, - }, []string{"legacy"}) + } + b.EnsureSessionMetadata("canonical", scope, []string{"legacy"}) if got := b.ResolveSessionKey("legacy"); got != "canonical" { t.Fatalf("ResolveSessionKey() = %q, want %q", got, "canonical") @@ -204,4 +205,37 @@ func TestJSONLBackend_ResolveAliasAndPersistMetadata(t *testing.T) { if history[0].Content != "hello through alias" { t.Fatalf("history[0].Content = %q, want %q", history[0].Content, "hello through alias") } + + resolvedScope := b.GetSessionScope("legacy") + if resolvedScope == nil { + t.Fatal("GetSessionScope() returned nil") + } + if resolvedScope.AgentID != scope.AgentID || resolvedScope.Values["chat"] != scope.Values["chat"] { + t.Fatalf("GetSessionScope() = %+v, want %+v", resolvedScope, scope) + } +} + +func TestJSONLBackend_EnsureSessionMetadata_PromotesLegacyAliasHistory(t *testing.T) { + b := newBackend(t) + + legacyKey := "agent:main:direct:legacy-user" + b.AddMessage(legacyKey, "user", "legacy history") + b.SetSummary(legacyKey, "legacy summary") + + canonicalKey := session.BuildOpaqueSessionKey(legacyKey) + b.EnsureSessionMetadata(canonicalKey, &session.SessionScope{ + Version: session.ScopeVersionV1, + AgentID: "main", + }, []string{legacyKey}) + + if got := b.ResolveSessionKey(legacyKey); got != canonicalKey { + t.Fatalf("ResolveSessionKey() = %q, want %q", got, canonicalKey) + } + history := b.GetHistory(canonicalKey) + if len(history) != 1 || history[0].Content != "legacy history" { + t.Fatalf("promoted history = %+v", history) + } + if summary := b.GetSummary(canonicalKey); summary != "legacy summary" { + t.Fatalf("promoted summary = %q, want %q", summary, "legacy summary") + } } diff --git a/pkg/session/key.go b/pkg/session/key.go new file mode 100644 index 000000000..77dd115f5 --- /dev/null +++ b/pkg/session/key.go @@ -0,0 +1,52 @@ +package session + +import ( + "crypto/sha256" + "encoding/hex" + "fmt" + "strings" +) + +const sessionKeyV1Prefix = "sk_v1_" + +// BuildOpaqueSessionKey returns a stable opaque session key derived from a +// canonical alias string. The alias remains available through metadata for +// compatibility and migration purposes. +func BuildOpaqueSessionKey(alias string) string { + normalized := strings.TrimSpace(strings.ToLower(alias)) + if normalized == "" { + return "" + } + sum := sha256.Sum256([]byte(normalized)) + return sessionKeyV1Prefix + hex.EncodeToString(sum[:]) +} + +// IsOpaqueSessionKey returns true when the key matches the current opaque +// session-key format. +func IsOpaqueSessionKey(key string) bool { + return strings.HasPrefix(strings.ToLower(strings.TrimSpace(key)), sessionKeyV1Prefix) +} + +// CanonicalScopeSignature returns a stable serialized representation of scope. +func CanonicalScopeSignature(scope SessionScope) string { + parts := []string{ + fmt.Sprintf("v=%d", scope.Version), + fmt.Sprintf("agent=%s", strings.TrimSpace(strings.ToLower(scope.AgentID))), + fmt.Sprintf("channel=%s", strings.TrimSpace(strings.ToLower(scope.Channel))), + fmt.Sprintf("account=%s", strings.TrimSpace(strings.ToLower(scope.Account))), + } + for _, dimension := range scope.Dimensions { + dimension = strings.TrimSpace(strings.ToLower(dimension)) + if dimension == "" { + continue + } + value := strings.TrimSpace(strings.ToLower(scope.Values[dimension])) + parts = append(parts, fmt.Sprintf("%s=%s", dimension, value)) + } + return strings.Join(parts, "|") +} + +// BuildSessionKey returns the current opaque key for a structured session scope. +func BuildSessionKey(scope SessionScope) string { + return BuildOpaqueSessionKey(CanonicalScopeSignature(scope)) +} From 59dee895fc906827df14f05fb36303a31686d080 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 20:56:48 +0800 Subject: [PATCH 012/174] refactor(runtime): drop non-session legacy context compatibility --- pkg/agent/eventbus_test.go | 6 - pkg/agent/events.go | 4 - pkg/agent/hooks.go | 10 - pkg/agent/loop.go | 183 +++---------- pkg/agent/loop_test.go | 243 ++++++++---------- pkg/agent/registry.go | 7 +- pkg/agent/steering.go | 3 +- pkg/agent/steering_test.go | 62 +++-- pkg/bus/bus.go | 15 ++ pkg/bus/bus_test.go | 174 +++++++++---- pkg/bus/inbound_context.go | 216 +--------------- pkg/bus/outbound_context.go | 64 ++--- pkg/bus/types.go | 35 +-- pkg/channels/base.go | 46 +--- pkg/channels/base_test.go | 56 ++++ pkg/channels/dingtalk/dingtalk.go | 32 ++- pkg/channels/discord/discord.go | 6 +- pkg/channels/feishu/feishu_64.go | 35 ++- pkg/channels/irc/handler.go | 23 +- pkg/channels/line/line.go | 11 +- pkg/channels/maixcam/maixcam.go | 20 +- pkg/channels/manager.go | 66 +++-- pkg/channels/manager_test.go | 181 +++++++++---- pkg/channels/matrix/matrix.go | 26 +- pkg/channels/onebot/onebot.go | 6 +- pkg/channels/pico/client.go | 19 +- pkg/channels/pico/pico.go | 13 +- pkg/channels/qq/qq.go | 20 +- pkg/channels/slack/slack.go | 24 +- pkg/channels/telegram/telegram.go | 5 - pkg/channels/wecom/wecom.go | 3 +- pkg/channels/weixin/weixin.go | 18 +- pkg/channels/whatsapp/whatsapp.go | 22 +- .../whatsapp_native/whatsapp_native.go | 13 +- pkg/config/config.go | 6 +- pkg/devices/service.go | 3 +- pkg/heartbeat/service.go | 3 +- pkg/routing/route.go | 79 ++++-- pkg/routing/route_test.go | 73 +++--- pkg/routing/session_key.go | 218 ---------------- pkg/routing/session_key_test.go | 207 --------------- pkg/session/allocator.go | 41 +-- pkg/session/key.go | 135 +++++++++- pkg/session/key_test.go | 72 ++++++ pkg/tools/cron.go | 6 +- 45 files changed, 1083 insertions(+), 1427 deletions(-) delete mode 100644 pkg/routing/session_key.go delete mode 100644 pkg/routing/session_key_test.go create mode 100644 pkg/session/key_test.go diff --git a/pkg/agent/eventbus_test.go b/pkg/agent/eventbus_test.go index 574d7bbcc..66046f87b 100644 --- a/pkg/agent/eventbus_test.go +++ b/pkg/agent/eventbus_test.go @@ -610,12 +610,6 @@ func TestAgentLoop_EmitsFollowUpQueuedEvent(t *testing.T) { if payload.SourceTool != "async_followup" { t.Fatalf("expected source tool async_followup, got %q", payload.SourceTool) } - if payload.Channel != "cli" { - t.Fatalf("expected channel cli, got %q", payload.Channel) - } - if payload.ChatID != "direct" { - t.Fatalf("expected chat id direct, got %q", payload.ChatID) - } if payload.ContentLen != len("background result") { t.Fatalf("expected content len %d, got %d", len("background result"), payload.ContentLen) } diff --git a/pkg/agent/events.go b/pkg/agent/events.go index d17f5a90b..6741d0053 100644 --- a/pkg/agent/events.go +++ b/pkg/agent/events.go @@ -116,8 +116,6 @@ const ( // TurnStartPayload describes the start of a turn. type TurnStartPayload struct { - Channel string - ChatID string UserMessage string MediaCount int } @@ -217,8 +215,6 @@ type SteeringInjectedPayload struct { // FollowUpQueuedPayload describes an async follow-up queued back into the inbound bus. type FollowUpQueuedPayload struct { SourceTool string - Channel string - ChatID string ContentLen int } diff --git a/pkg/agent/hooks.go b/pkg/agent/hooks.go index c3c4b21ce..0e0c139ae 100644 --- a/pkg/agent/hooks.go +++ b/pkg/agent/hooks.go @@ -94,8 +94,6 @@ type LLMHookRequest struct { Messages []providers.Message `json:"messages,omitempty"` Tools []providers.ToolDefinition `json:"tools,omitempty"` Options map[string]any `json:"options,omitempty"` - Channel string `json:"channel,omitempty"` - ChatID string `json:"chat_id,omitempty"` GracefulTerminal bool `json:"graceful_terminal,omitempty"` } @@ -117,8 +115,6 @@ type LLMHookResponse struct { Context *TurnContext `json:"context,omitempty"` Model string `json:"model"` Response *providers.LLMResponse `json:"response,omitempty"` - Channel string `json:"channel,omitempty"` - ChatID string `json:"chat_id,omitempty"` } func (r *LLMHookResponse) Clone() *LLMHookResponse { @@ -137,8 +133,6 @@ type ToolCallHookRequest struct { Context *TurnContext `json:"context,omitempty"` Tool string `json:"tool"` Arguments map[string]any `json:"arguments,omitempty"` - Channel string `json:"channel,omitempty"` - ChatID string `json:"chat_id,omitempty"` } func (r *ToolCallHookRequest) Clone() *ToolCallHookRequest { @@ -157,8 +151,6 @@ type ToolApprovalRequest struct { Context *TurnContext `json:"context,omitempty"` Tool string `json:"tool"` Arguments map[string]any `json:"arguments,omitempty"` - Channel string `json:"channel,omitempty"` - ChatID string `json:"chat_id,omitempty"` } func (r *ToolApprovalRequest) Clone() *ToolApprovalRequest { @@ -179,8 +171,6 @@ type ToolResultHookResponse struct { Arguments map[string]any `json:"arguments,omitempty"` Result *tools.ToolResult `json:"result,omitempty"` Duration time.Duration `json:"duration"` - Channel string `json:"channel,omitempty"` - ChatID string `json:"chat_id,omitempty"` } func (r *ToolResultHookResponse) Clone() *ToolResultHookResponse { diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go index 70827598a..b12ad5b1d 100644 --- a/pkg/agent/loop.go +++ b/pkg/agent/loop.go @@ -107,14 +107,6 @@ const ( defaultResponse = "The model returned an empty response. This may indicate a provider error or token limit." toolLimitResponse = "I've reached `max_tool_iterations` without a final response. Increase `max_tool_iterations` in config.json if this task needs more tool steps." handledToolResponseSummary = "Requested output delivered via tool attachment." - sessionKeyAgentPrefix = "agent:" - sessionKeyOpaquePrefix = "sk_" - metadataKeyAccountID = "account_id" - metadataKeyGuildID = "guild_id" - metadataKeyTeamID = "team_id" - metadataKeyReplyToMessage = "reply_to_message_id" - metadataKeyParentPeerKind = "parent_peer_kind" - metadataKeyParentPeerID = "parent_peer_id" ) func NewAgentLoop( @@ -234,9 +226,9 @@ func registerSharedTools( messageTool.SetSendCallback(func(channel, chatID, content, replyToMessageID string) error { pubCtx, pubCancel := context.WithTimeout(context.Background(), 5*time.Second) defer pubCancel() + outboundCtx := bus.NewOutboundContext(channel, chatID, replyToMessageID) return msgBus.PublishOutbound(pubCtx, bus.OutboundMessage{ - Channel: channel, - ChatID: chatID, + Context: outboundCtx, Content: content, ReplyToMessageID: replyToMessageID, }) @@ -657,8 +649,7 @@ func (al *AgentLoop) PublishResponseIfNeeded(ctx context.Context, channel, chatI } al.bus.PublishOutbound(ctx, bus.OutboundMessage{ - Channel: channel, - ChatID: chatID, + Context: bus.NewOutboundContext(channel, chatID, ""), Content: response, }) logger.InfoCF("agent", "Published outbound response", @@ -714,11 +705,7 @@ func outboundContextFromInbound( channel, chatID, replyToMessageID string, ) bus.InboundContext { if inbound == nil { - return bus.ContextFromLegacyOutbound(bus.OutboundMessage{ - Channel: channel, - ChatID: chatID, - ReplyToMessageID: replyToMessageID, - }) + return bus.NewOutboundContext(channel, chatID, replyToMessageID) } outboundCtx := *cloneInboundContext(inbound) @@ -736,8 +723,6 @@ func outboundContextFromInbound( func outboundMessageForTurn(ts *turnState, content string) bus.OutboundMessage { return bus.OutboundMessage{ - Channel: ts.channel, - ChatID: ts.chatID, Context: outboundContextFromInbound( ts.opts.InboundContext, ts.channel, @@ -894,8 +879,6 @@ func (al *AgentLoop) logEvent(evt Event) { switch payload := evt.Payload.(type) { case TurnStartPayload: - fields["channel"] = payload.Channel - fields["chat_id"] = payload.ChatID fields["user_len"] = len(payload.UserMessage) fields["media_count"] = payload.MediaCount case TurnEndPayload: @@ -948,8 +931,6 @@ func (al *AgentLoop) logEvent(evt Event) { fields["total_content_len"] = payload.TotalContentLen case FollowUpQueuedPayload: fields["source_tool"] = payload.SourceTool - fields["channel"] = payload.Channel - fields["chat_id"] = payload.ChatID fields["content_len"] = payload.ContentLen case InterruptReceivedPayload: fields["interrupt_kind"] = payload.Kind @@ -1292,8 +1273,7 @@ func (al *AgentLoop) sendTranscriptionFeedback( } err := al.channelManager.SendMessage(ctx, bus.OutboundMessage{ - Channel: channel, - ChatID: chatID, + Context: bus.NewOutboundContext(channel, chatID, messageID), Content: feedbackMsg, ReplyToMessageID: messageID, }) @@ -1369,13 +1349,15 @@ func (al *AgentLoop) ProcessDirectWithChannel( } msg := bus.InboundMessage{ - Channel: channel, - SenderID: "cron", - ChatID: chatID, + Context: bus.InboundContext{ + Channel: channel, + ChatID: chatID, + ChatType: "direct", + SenderID: "cron", + }, Content: content, SessionKey: sessionKey, } - msg.Context = bus.ContextFromLegacyInbound(msg) return al.processMessage(ctx, msg) } @@ -1481,7 +1463,7 @@ func (al *AgentLoop) processMessage(ctx context.Context, msg bus.InboundMessage) Channel: msg.Channel, ChatID: msg.ChatID, MessageID: msg.MessageID, - ReplyToMessageID: inboundMetadata(msg, metadataKeyReplyToMessage), + ReplyToMessageID: msg.Context.ReplyToMessageID, SenderID: msg.SenderID, SenderDisplayName: msg.Sender.DisplayName, UserMessage: msg.Content, @@ -1515,18 +1497,7 @@ func (al *AgentLoop) processMessage(ctx context.Context, msg bus.InboundMessage) func (al *AgentLoop) resolveMessageRoute(msg bus.InboundMessage) (routing.ResolvedRoute, *AgentInstance, error) { registry := al.GetRegistry() inboundCtx := normalizedInboundContext(msg) - channel := strings.TrimSpace(inboundCtx.Channel) - if channel == "" { - channel = msg.Channel - } - route := registry.ResolveRoute(routing.RouteInput{ - Channel: channel, - AccountID: routeAccountID(msg), - Peer: extractPeer(msg), - ParentPeer: extractParentPeer(msg), - GuildID: routeGuildID(msg), - TeamID: routeTeamID(msg), - }) + route := registry.ResolveRoute(inboundCtx) agent, ok := registry.GetAgent(route.AgentID) if !ok { @@ -1551,8 +1522,7 @@ func resolveScopeKey(routeSessionKey, msgSessionKey string) string { } func isExplicitSessionKey(sessionKey string) bool { - sessionKey = strings.TrimSpace(strings.ToLower(sessionKey)) - return strings.HasPrefix(sessionKey, sessionKeyAgentPrefix) || strings.HasPrefix(sessionKey, sessionKeyOpaquePrefix) + return session.IsExplicitSessionKey(sessionKey) } func buildSessionAliases(canonicalKey string, keys ...string) []string { @@ -1621,8 +1591,7 @@ func (al *AgentLoop) requeueInboundMessage(msg bus.InboundMessage) error { pubCtx, cancel := context.WithTimeout(context.Background(), time.Second) defer cancel() return al.bus.PublishOutbound(pubCtx, bus.OutboundMessage{ - Channel: msg.Channel, - ChatID: msg.ChatID, + Context: msg.Context, Content: msg.Content, }) } @@ -1679,7 +1648,7 @@ func (al *AgentLoop) processSystemMessage( } // Use the origin session for context - sessionKey := routing.BuildAgentMainSessionKey(agent.ID) + sessionKey := session.BuildMainSessionKey(agent.ID) return al.runAgentLoop(ctx, agent, processOptions{ SessionKey: sessionKey, @@ -1739,8 +1708,6 @@ func (al *AgentLoop) runAgentLoop( if opts.SendResponse && result.finalContent != "" { al.bus.PublishOutbound(ctx, bus.OutboundMessage{ - Channel: opts.Channel, - ChatID: opts.ChatID, Context: outboundContextFromInbound( opts.InboundContext, opts.Channel, @@ -1796,8 +1763,7 @@ func (al *AgentLoop) handleReasoning( defer pubCancel() if err := al.bus.PublishOutbound(pubCtx, bus.OutboundMessage{ - Channel: channelName, - ChatID: channelID, + Context: bus.NewOutboundContext(channelName, channelID, ""), Content: reasoningContent, }); err != nil { // Treat context.DeadlineExceeded / context.Canceled as expected @@ -1851,8 +1817,6 @@ func (al *AgentLoop) runTurn(ctx context.Context, ts *turnState) (turnResult, er EventKindTurnStart, ts.eventMeta("runTurn", "turn.start"), TurnStartPayload{ - Channel: ts.channel, - ChatID: ts.chatID, UserMessage: ts.userMessage, MediaCount: len(ts.media), }, @@ -2085,8 +2049,6 @@ turnLoop: Messages: callMessages, Tools: providerToolDefs, Options: llmOpts, - Channel: ts.channel, - ChatID: ts.chatID, GracefulTerminal: gracefulTerminal, }) switch decision.normalizedAction() { @@ -2314,8 +2276,6 @@ turnLoop: Context: cloneTurnContext(ts.turnCtx), Model: llmModel, Response: response, - Channel: ts.channel, - ChatID: ts.chatID, }) switch decision.normalizedAction() { case HookActionContinue, HookActionModify: @@ -2346,7 +2306,7 @@ turnLoop: reasoningContent = response.ReasoningContent } go al.handleReasoning( - turnCtx, + ctx, reasoningContent, ts.channel, al.targetReasoningChannelID(ts.channel), @@ -2467,8 +2427,6 @@ turnLoop: Context: cloneTurnContext(ts.turnCtx), Tool: toolName, Arguments: toolArgs, - Channel: ts.channel, - ChatID: ts.chatID, }) switch decision.normalizedAction() { case HookActionContinue, HookActionModify: @@ -2514,8 +2472,6 @@ turnLoop: Context: cloneTurnContext(ts.turnCtx), Tool: toolName, Arguments: toolArgs, - Channel: ts.channel, - ChatID: ts.chatID, }) if !approval.Approved { allResponsesHandled = false @@ -2605,8 +2561,6 @@ turnLoop: ts.scope.meta(toolIteration, "runTurn", "turn.follow_up.queued"), FollowUpQueuedPayload{ SourceTool: asyncToolName, - Channel: ts.channel, - ChatID: ts.chatID, ContentLen: len(content), }, ) @@ -2614,10 +2568,13 @@ turnLoop: pubCtx, pubCancel := context.WithTimeout(context.Background(), 5*time.Second) defer pubCancel() _ = al.bus.PublishInbound(pubCtx, bus.InboundMessage{ - Channel: "system", - SenderID: fmt.Sprintf("async:%s", asyncToolName), - ChatID: fmt.Sprintf("%s:%s", ts.channel, ts.chatID), - Content: content, + Context: bus.InboundContext{ + Channel: "system", + ChatID: fmt.Sprintf("%s:%s", ts.channel, ts.chatID), + ChatType: "direct", + SenderID: fmt.Sprintf("async:%s", asyncToolName), + }, + Content: content, }) } @@ -2652,8 +2609,6 @@ turnLoop: Arguments: toolArgs, Result: toolResult, Duration: toolDuration, - Channel: ts.channel, - ChatID: ts.chatID, }) switch decision.normalizedAction() { case HookActionContinue, HookActionModify: @@ -2692,9 +2647,13 @@ turnLoop: parts = append(parts, part) } outboundMedia := bus.OutboundMediaMessage{ - Channel: ts.channel, - ChatID: ts.chatID, - Parts: parts, + Context: outboundContextFromInbound( + ts.opts.InboundContext, + ts.channel, + ts.chatID, + ts.opts.ReplyToMessageID, + ), + Parts: parts, } if al.channelManager != nil && ts.channel != "" && !constants.IsInternalChannel(ts.channel) { if err := al.channelManager.SendMedia(ctx, outboundMedia); err != nil { @@ -3758,84 +3717,6 @@ func mapCommandError(result commands.ExecuteResult) string { return fmt.Sprintf("Failed to execute /%s: %v", result.Command, result.Err) } -// extractPeer extracts the routing peer from the inbound message's structured Peer field. -func extractPeer(msg bus.InboundMessage) *routing.RoutePeer { - if msg.Peer.Kind != "" { - peerID := msg.Peer.ID - if peerID == "" { - if msg.Peer.Kind == "direct" { - peerID = msg.SenderID - } else { - peerID = msg.ChatID - } - } - return &routing.RoutePeer{Kind: msg.Peer.Kind, ID: peerID} - } - - inboundCtx := normalizedInboundContext(msg) - peerKind := strings.TrimSpace(inboundCtx.ChatType) - if peerKind == "" { - return nil - } - - peerID := strings.TrimSpace(inboundCtx.ChatID) - if peerKind == "direct" && peerID == "" { - peerID = strings.TrimSpace(inboundCtx.SenderID) - } - if peerID == "" { - return nil - } - return &routing.RoutePeer{Kind: peerKind, ID: peerID} -} - -func inboundMetadata(msg bus.InboundMessage, key string) string { - if msg.Metadata == nil { - return "" - } - return msg.Metadata[key] -} - -// extractParentPeer extracts the parent peer (reply-to) from inbound message metadata. -func extractParentPeer(msg bus.InboundMessage) *routing.RoutePeer { - inboundCtx := normalizedInboundContext(msg) - if topicID := strings.TrimSpace(inboundCtx.TopicID); topicID != "" { - return &routing.RoutePeer{Kind: "topic", ID: topicID} - } - - parentKind := inboundMetadata(msg, metadataKeyParentPeerKind) - parentID := inboundMetadata(msg, metadataKeyParentPeerID) - if parentKind == "" || parentID == "" { - return nil - } - return &routing.RoutePeer{Kind: parentKind, ID: parentID} -} - -func routeAccountID(msg bus.InboundMessage) string { - if accountID := strings.TrimSpace(normalizedInboundContext(msg).Account); accountID != "" { - return accountID - } - return inboundMetadata(msg, metadataKeyAccountID) -} - -func routeGuildID(msg bus.InboundMessage) string { - inboundCtx := normalizedInboundContext(msg) - if strings.EqualFold(strings.TrimSpace(inboundCtx.SpaceType), "guild") { - return strings.TrimSpace(inboundCtx.SpaceID) - } - return inboundMetadata(msg, metadataKeyGuildID) -} - -func routeTeamID(msg bus.InboundMessage) string { - inboundCtx := normalizedInboundContext(msg) - switch strings.ToLower(strings.TrimSpace(inboundCtx.SpaceType)) { - case "team", "workspace": - if spaceID := strings.TrimSpace(inboundCtx.SpaceID); spaceID != "" { - return spaceID - } - } - return inboundMetadata(msg, metadataKeyTeamID) -} - // isNativeSearchProvider reports whether the given LLM provider implements // NativeSearchCapable and returns true for SupportsNativeSearch. func isNativeSearchProvider(p providers.LLMProvider) bool { diff --git a/pkg/agent/loop_test.go b/pkg/agent/loop_test.go index 3efb7ddfd..4aa356f88 100644 --- a/pkg/agent/loop_test.go +++ b/pkg/agent/loop_test.go @@ -140,7 +140,7 @@ func TestProcessMessage_IncludesCurrentSenderInDynamicContext(t *testing.T) { provider := &recordingProvider{} al := NewAgentLoop(cfg, msgBus, provider) - response, err := al.processMessage(context.Background(), bus.InboundMessage{ + response, err := al.processMessage(context.Background(), testInboundMessage(bus.InboundMessage{ Channel: "discord", SenderID: "discord:123", Sender: bus.SenderInfo{ @@ -148,7 +148,7 @@ func TestProcessMessage_IncludesCurrentSenderInDynamicContext(t *testing.T) { }, ChatID: "group-1", Content: "hello", - }) + })) if err != nil { t.Fatalf("processMessage() error = %v", err) } @@ -199,12 +199,12 @@ func TestProcessMessage_UseCommandLoadsRequestedSkill(t *testing.T) { provider := &recordingProvider{} al := NewAgentLoop(cfg, msgBus, provider) - response, err := al.processMessage(context.Background(), bus.InboundMessage{ + response, err := al.processMessage(context.Background(), testInboundMessage(bus.InboundMessage{ Channel: "telegram", SenderID: "telegram:123", ChatID: "chat-1", Content: "/use shell explain how to list files", - }) + })) if err != nil { t.Fatalf("processMessage() error = %v", err) } @@ -289,12 +289,12 @@ func TestProcessMessage_UseCommandArmsSkillForNextMessage(t *testing.T) { provider := &recordingProvider{} al := NewAgentLoop(cfg, msgBus, provider) - response, err := al.processMessage(context.Background(), bus.InboundMessage{ + response, err := al.processMessage(context.Background(), testInboundMessage(bus.InboundMessage{ Channel: "telegram", SenderID: "telegram:123", ChatID: "chat-1", Content: "/use shell", - }) + })) if err != nil { t.Fatalf("processMessage() arm error = %v", err) } @@ -302,12 +302,12 @@ func TestProcessMessage_UseCommandArmsSkillForNextMessage(t *testing.T) { t.Fatalf("arm response = %q, want armed confirmation", response) } - response, err = al.processMessage(context.Background(), bus.InboundMessage{ + response, err = al.processMessage(context.Background(), testInboundMessage(bus.InboundMessage{ Channel: "telegram", SenderID: "telegram:123", ChatID: "chat-1", Content: "explain how to list files", - }) + })) if err != nil { t.Fatalf("processMessage() follow-up error = %v", err) } @@ -620,12 +620,12 @@ func TestProcessMessage_MediaToolHandledSkipsFollowUpLLMAndFinalText(t *testing. path: imagePath, }) - response, err := al.processMessage(context.Background(), bus.InboundMessage{ + response, err := al.processMessage(context.Background(), testInboundMessage(bus.InboundMessage{ Channel: "telegram", ChatID: "chat1", SenderID: "user1", Content: "take a screenshot of the screen and send it to me", - }) + })) if err != nil { t.Fatalf("processMessage() error = %v", err) } @@ -662,21 +662,21 @@ func TestProcessMessage_MediaToolHandledSkipsFollowUpLLMAndFinalText(t *testing. if defaultAgent == nil { t.Fatal("expected default agent") } - route, _, err := al.resolveMessageRoute(bus.InboundMessage{ + route, _, err := al.resolveMessageRoute(testInboundMessage(bus.InboundMessage{ Channel: "telegram", ChatID: "chat1", SenderID: "user1", Content: "take a screenshot of the screen and send it to me", - }) + })) if err != nil { t.Fatalf("resolveMessageRoute() error = %v", err) } - sessionKey := resolveScopeKey(al.allocateRouteSession(route, bus.InboundMessage{ + sessionKey := resolveScopeKey(al.allocateRouteSession(route, testInboundMessage(bus.InboundMessage{ Channel: "telegram", ChatID: "chat1", SenderID: "user1", Content: "take a screenshot of the screen and send it to me", - }).SessionKey, "") + })).SessionKey, "") history := defaultAgent.Sessions.GetHistory(sessionKey) if len(history) == 0 { t.Fatal("expected session history to be saved") @@ -720,12 +720,12 @@ func TestProcessMessage_HandledToolProcessesQueuedSteeringBeforeReturning(t *tes loop: al, }) - response, err := al.processMessage(context.Background(), bus.InboundMessage{ + response, err := al.processMessage(context.Background(), testInboundMessage(bus.InboundMessage{ Channel: "telegram", ChatID: "chat1", SenderID: "user1", Content: "take a screenshot of the screen and send it to me", - }) + })) if err != nil { t.Fatalf("processMessage() error = %v", err) } @@ -740,41 +740,6 @@ func TestProcessMessage_HandledToolProcessesQueuedSteeringBeforeReturning(t *tes } } -func TestExtractPeer_UsesInboundContextWhenLegacyPeerMissing(t *testing.T) { - msg := bus.InboundMessage{ - Context: bus.InboundContext{ - Channel: "slack", - ChatID: "C001", - ChatType: "channel", - SenderID: "U001", - }, - } - - peer := extractPeer(msg) - if peer == nil { - t.Fatal("expected peer from inbound context") - } - if peer.Kind != "channel" || peer.ID != "C001" { - t.Fatalf("peer = %+v, want channel/C001", peer) - } -} - -func TestExtractParentPeer_UsesInboundContextTopicID(t *testing.T) { - msg := bus.InboundMessage{ - Context: bus.InboundContext{ - TopicID: "thread-42", - }, - } - - parentPeer := extractParentPeer(msg) - if parentPeer == nil { - t.Fatal("expected parent peer from topic context") - } - if parentPeer.Kind != "topic" || parentPeer.ID != "thread-42" { - t.Fatalf("parent peer = %+v, want topic/thread-42", parentPeer) - } -} - func TestAppendEventContextFields_IncludesInboundRouteAndScope(t *testing.T) { fields := map[string]any{} @@ -872,7 +837,7 @@ func TestResolveMessageRoute_UsesInboundContextAccountAndSpace(t *testing.T) { msgBus := bus.NewMessageBus() al := NewAgentLoop(cfg, msgBus, &simpleMockProvider{response: "ok"}) - route, _, err := al.resolveMessageRoute(bus.InboundMessage{ + route, _, err := al.resolveMessageRoute(testInboundMessage(bus.InboundMessage{ Context: bus.InboundContext{ Channel: "slack", Account: "workspace-a", @@ -883,7 +848,7 @@ func TestResolveMessageRoute_UsesInboundContextAccountAndSpace(t *testing.T) { SpaceType: "workspace", }, Content: "hello", - }) + })) if err != nil { t.Fatalf("resolveMessageRoute() error = %v", err) } @@ -926,12 +891,12 @@ func TestProcessMessage_MediaArtifactCanBeForwardedBySendFile(t *testing.T) { path: imagePath, }) - response, err := al.processMessage(context.Background(), bus.InboundMessage{ + response, err := al.processMessage(context.Background(), testInboundMessage(bus.InboundMessage{ Channel: "telegram", ChatID: "chat1", SenderID: "user1", Content: "take a screenshot of the screen and send it to me", - }) + })) if err != nil { t.Fatalf("processMessage() error = %v", err) } @@ -1518,13 +1483,39 @@ func (h testHelper) executeAndGetResponse(tb testing.TB, ctx context.Context, ms timeoutCtx, cancel := context.WithTimeout(ctx, responseTimeout) defer cancel() - response, err := h.al.processMessage(timeoutCtx, msg) + response, err := h.al.processMessage(timeoutCtx, testInboundMessage(msg)) if err != nil { tb.Fatalf("processMessage failed: %v", err) } return response } +func testInboundMessage(msg bus.InboundMessage) bus.InboundMessage { + if msg.Context.Channel == "" && + msg.Context.Account == "" && + msg.Context.ChatID == "" && + msg.Context.ChatType == "" && + msg.Context.TopicID == "" && + msg.Context.SpaceID == "" && + msg.Context.SpaceType == "" && + msg.Context.SenderID == "" && + msg.Context.MessageID == "" && + !msg.Context.Mentioned && + msg.Context.ReplyToMessageID == "" && + msg.Context.ReplyToSenderID == "" && + len(msg.Context.ReplyHandles) == 0 && + len(msg.Context.Raw) == 0 { + msg.Context = bus.InboundContext{ + Channel: msg.Channel, + ChatID: msg.ChatID, + ChatType: "direct", + SenderID: msg.SenderID, + MessageID: msg.MessageID, + } + } + return bus.NormalizeInboundMessage(msg) +} + const responseTimeout = 3 * time.Second func TestProcessMessage_UsesRouteSessionKey(t *testing.T) { @@ -1550,20 +1541,16 @@ func TestProcessMessage_UsesRouteSessionKey(t *testing.T) { al := NewAgentLoop(cfg, msgBus, provider) msg := bus.InboundMessage{ - Channel: "telegram", - SenderID: "user1", - ChatID: "chat1", - Content: "hello", - Peer: bus.Peer{ - Kind: "direct", - ID: "user1", + Context: bus.InboundContext{ + Channel: "telegram", + ChatID: "chat1", + ChatType: "direct", + SenderID: "user1", }, + Content: "hello", } - route := al.registry.ResolveRoute(routing.RouteInput{ - Channel: msg.Channel, - Peer: extractPeer(msg), - }) + route := al.registry.ResolveRoute(bus.NormalizeInboundMessage(msg).Context) sessionKey := al.allocateRouteSession(route, msg).SessionKey defaultAgent := al.registry.GetDefaultAgent() @@ -1610,21 +1597,22 @@ func TestProcessMessage_CommandOutcomes(t *testing.T) { helper := testHelper{al: al} baseMsg := bus.InboundMessage{ - Channel: "whatsapp", - SenderID: "user1", - ChatID: "chat1", - Peer: bus.Peer{ - Kind: "direct", - ID: "user1", + Context: bus.InboundContext{ + Channel: "whatsapp", + ChatID: "chat1", + ChatType: "direct", + SenderID: "user1", }, } showResp := helper.executeAndGetResponse(t, context.Background(), bus.InboundMessage{ - Channel: baseMsg.Channel, - SenderID: baseMsg.SenderID, - ChatID: baseMsg.ChatID, - Content: "/show channel", - Peer: baseMsg.Peer, + Context: bus.InboundContext{ + Channel: baseMsg.Context.Channel, + ChatID: baseMsg.Context.ChatID, + ChatType: baseMsg.Context.ChatType, + SenderID: baseMsg.Context.SenderID, + }, + Content: "/show channel", }) if showResp != "Current Channel: whatsapp" { t.Fatalf("unexpected /show reply: %q", showResp) @@ -1634,11 +1622,13 @@ func TestProcessMessage_CommandOutcomes(t *testing.T) { } fooResp := helper.executeAndGetResponse(t, context.Background(), bus.InboundMessage{ - Channel: baseMsg.Channel, - SenderID: baseMsg.SenderID, - ChatID: baseMsg.ChatID, - Content: "/foo", - Peer: baseMsg.Peer, + Context: bus.InboundContext{ + Channel: baseMsg.Context.Channel, + ChatID: baseMsg.Context.ChatID, + ChatType: baseMsg.Context.ChatType, + SenderID: baseMsg.Context.SenderID, + }, + Content: "/foo", }) if fooResp != "LLM reply" { t.Fatalf("unexpected /foo reply: %q", fooResp) @@ -1648,11 +1638,13 @@ func TestProcessMessage_CommandOutcomes(t *testing.T) { } newResp := helper.executeAndGetResponse(t, context.Background(), bus.InboundMessage{ - Channel: baseMsg.Channel, - SenderID: baseMsg.SenderID, - ChatID: baseMsg.ChatID, - Content: "/new", - Peer: baseMsg.Peer, + Context: bus.InboundContext{ + Channel: baseMsg.Context.Channel, + ChatID: baseMsg.Context.ChatID, + ChatType: baseMsg.Context.ChatType, + SenderID: baseMsg.Context.SenderID, + }, + Content: "/new", }) if newResp != "LLM reply" { t.Fatalf("unexpected /new reply: %q", newResp) @@ -1705,10 +1697,6 @@ func TestProcessMessage_SwitchModelShowModelConsistency(t *testing.T) { SenderID: "user1", ChatID: "chat1", Content: "/switch model to deepseek", - Peer: bus.Peer{ - Kind: "direct", - ID: "user1", - }, }) if !strings.Contains(switchResp, "Switched model from local to deepseek") { t.Fatalf("unexpected /switch reply: %q", switchResp) @@ -1719,10 +1707,6 @@ func TestProcessMessage_SwitchModelShowModelConsistency(t *testing.T) { SenderID: "user1", ChatID: "chat1", Content: "/show model", - Peer: bus.Peer{ - Kind: "direct", - ID: "user1", - }, }) if !strings.Contains(showResp, "Current Model: deepseek (Provider: openrouter)") { t.Fatalf("unexpected /show model reply after switch: %q", showResp) @@ -1770,10 +1754,6 @@ func TestProcessMessage_SwitchModelRejectsUnknownAlias(t *testing.T) { SenderID: "user1", ChatID: "chat1", Content: "/switch model to missing", - Peer: bus.Peer{ - Kind: "direct", - ID: "user1", - }, }) if switchResp != `model "missing" not found in model_list or providers` { t.Fatalf("unexpected /switch error reply: %q", switchResp) @@ -1784,10 +1764,6 @@ func TestProcessMessage_SwitchModelRejectsUnknownAlias(t *testing.T) { SenderID: "user1", ChatID: "chat1", Content: "/show model", - Peer: bus.Peer{ - Kind: "direct", - ID: "user1", - }, }) if !strings.Contains(showResp, "Current Model: local (Provider: openai)") { t.Fatalf("unexpected /show model reply after rejected switch: %q", showResp) @@ -1854,10 +1830,6 @@ func TestProcessMessage_SwitchModelRoutesSubsequentRequestsToSelectedProvider(t SenderID: "user1", ChatID: "chat1", Content: "hello before switch", - Peer: bus.Peer{ - Kind: "direct", - ID: "user1", - }, }) if firstResp != "local reply" { t.Fatalf("unexpected response before switch: %q", firstResp) @@ -1877,10 +1849,6 @@ func TestProcessMessage_SwitchModelRoutesSubsequentRequestsToSelectedProvider(t SenderID: "user1", ChatID: "chat1", Content: "/switch model to deepseek", - Peer: bus.Peer{ - Kind: "direct", - ID: "user1", - }, }) if !strings.Contains(switchResp, "Switched model from local to deepseek") { t.Fatalf("unexpected /switch reply: %q", switchResp) @@ -1891,10 +1859,6 @@ func TestProcessMessage_SwitchModelRoutesSubsequentRequestsToSelectedProvider(t SenderID: "user1", ChatID: "chat1", Content: "hello after switch", - Peer: bus.Peer{ - Kind: "direct", - ID: "user1", - }, }) if secondResp != "remote reply" { t.Fatalf("unexpected response after switch: %q", secondResp) @@ -1984,10 +1948,6 @@ func TestProcessMessage_ModelRoutingUsesLightProvider(t *testing.T) { SenderID: "user1", ChatID: "chat1", Content: "hi", - Peer: bus.Peer{ - Kind: "direct", - ID: "user1", - }, }) if resp != "light reply" { t.Fatalf("response = %q, want %q", resp, "light reply") @@ -2260,22 +2220,16 @@ func TestAgentLoop_ToolLimitUsesDedicatedFallback(t *testing.T) { if defaultAgent == nil { t.Fatal("No default agent found") } - route := al.registry.ResolveRoute(routing.RouteInput{ - Channel: "test", - Peer: &routing.RoutePeer{ - Kind: "direct", - ID: "cron", - }, + route := al.registry.ResolveRoute(bus.InboundContext{ + Channel: "test", + ChatType: "direct", + SenderID: "cron", }) - history := defaultAgent.Sessions.GetHistory(al.allocateRouteSession(route, bus.InboundMessage{ + history := defaultAgent.Sessions.GetHistory(al.allocateRouteSession(route, testInboundMessage(bus.InboundMessage{ Channel: "test", SenderID: "cron", ChatID: "chat1", - Peer: bus.Peer{ - Kind: "direct", - ID: "cron", - }, - }).SessionKey) + })).SessionKey) if len(history) != 4 { t.Fatalf("history len = %d, want 4", len(history)) } @@ -2533,8 +2487,7 @@ func TestHandleReasoning(t *testing.T) { for i := 0; ; i++ { fillCtx, fillCancel := context.WithTimeout(context.Background(), 50*time.Millisecond) err := msgBus.PublishOutbound(fillCtx, bus.OutboundMessage{ - Channel: "filler", - ChatID: "filler", + Context: bus.NewOutboundContext("filler", "filler", ""), Content: fmt.Sprintf("filler-%d", i), }) fillCancel() @@ -2608,12 +2561,12 @@ func TestProcessMessage_PublishesReasoningContentToReasoningChannel(t *testing.T chManager.RegisterChannel("telegram", &fakeChannel{id: "reason-chat"}) al.SetChannelManager(chManager) - response, err := al.processMessage(context.Background(), bus.InboundMessage{ + response, err := al.processMessage(context.Background(), testInboundMessage(bus.InboundMessage{ Channel: "telegram", SenderID: "user1", ChatID: "chat1", Content: "hello", - }) + })) if err != nil { t.Fatalf("processMessage() error = %v", err) } @@ -2629,6 +2582,9 @@ func TestProcessMessage_PublishesReasoningContentToReasoningChannel(t *testing.T if outbound.ChatID != "reason-chat" { t.Fatalf("reasoning chatID = %q, want %q", outbound.ChatID, "reason-chat") } + if outbound.Context.Channel != "telegram" || outbound.Context.ChatID != "reason-chat" { + t.Fatalf("unexpected reasoning context: %+v", outbound.Context) + } if outbound.Content != "thinking trace" { t.Fatalf("reasoning content = %q, want %q", outbound.Content, "thinking trace") } @@ -2714,12 +2670,12 @@ func TestProcessMessage_PublishesToolFeedbackWhenEnabled(t *testing.T) { provider := &toolFeedbackProvider{filePath: heartbeatFile} al := NewAgentLoop(cfg, msgBus, provider) - response, err := al.processMessage(context.Background(), bus.InboundMessage{ + response, err := al.processMessage(context.Background(), testInboundMessage(bus.InboundMessage{ Channel: "telegram", SenderID: "user-1", ChatID: "chat-1", Content: "check tool feedback", - }) + })) if err != nil { t.Fatalf("processMessage() error = %v", err) } @@ -2735,6 +2691,9 @@ func TestProcessMessage_PublishesToolFeedbackWhenEnabled(t *testing.T) { if outbound.ChatID != "chat-1" { t.Fatalf("tool feedback chatID = %q, want %q", outbound.ChatID, "chat-1") } + if outbound.Context.Channel != "telegram" || outbound.Context.ChatID != "chat-1" { + t.Fatalf("unexpected tool feedback context: %+v", outbound.Context) + } if !strings.Contains(outbound.Content, "`read_file`") { t.Fatalf("tool feedback content = %q, want read_file preview", outbound.Content) } @@ -3157,13 +3116,13 @@ func TestProcessMessage_ContextOverflowRecovery(t *testing.T) { agent.Sessions.AddFullMessage(sessionKey, providers.Message{Role: "assistant", Content: "response"}) } - response, err := al.processMessage(context.Background(), bus.InboundMessage{ + response, err := al.processMessage(context.Background(), testInboundMessage(bus.InboundMessage{ Channel: "test", ChatID: "chat1", SenderID: "user1", SessionKey: "test-session", Content: "trigger recovery", - }) + })) if err != nil { t.Fatalf("processMessage() error = %v", err) } @@ -3199,12 +3158,12 @@ func TestProcessMessage_ContextOverflow_AnthropicStyle(t *testing.T) { return &providers.LLMResponse{Content: "Anthropic recovery success"}, nil } - response, err := al.processMessage(context.Background(), bus.InboundMessage{ + response, err := al.processMessage(context.Background(), testInboundMessage(bus.InboundMessage{ Channel: "test", ChatID: "chat1", SenderID: "user1", Content: "hello", - }) + })) if err != nil { t.Fatalf("processMessage() error = %v", err) } diff --git a/pkg/agent/registry.go b/pkg/agent/registry.go index 58b7ce440..8aa11e37b 100644 --- a/pkg/agent/registry.go +++ b/pkg/agent/registry.go @@ -3,6 +3,7 @@ package agent import ( "sync" + "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/config" "github.com/sipeed/picoclaw/pkg/logger" "github.com/sipeed/picoclaw/pkg/providers" @@ -64,9 +65,9 @@ func (r *AgentRegistry) GetAgent(agentID string) (*AgentInstance, bool) { return agent, ok } -// ResolveRoute determines which agent handles the message. -func (r *AgentRegistry) ResolveRoute(input routing.RouteInput) routing.ResolvedRoute { - return r.resolver.ResolveRoute(input) +// ResolveRoute determines which agent handles the normalized inbound context. +func (r *AgentRegistry) ResolveRoute(inbound bus.InboundContext) routing.ResolvedRoute { + return r.resolver.ResolveRoute(inbound) } // ListAgentIDs returns all registered agent IDs. diff --git a/pkg/agent/steering.go b/pkg/agent/steering.go index b5cf049b3..f72e761f4 100644 --- a/pkg/agent/steering.go +++ b/pkg/agent/steering.go @@ -8,7 +8,6 @@ import ( "github.com/sipeed/picoclaw/pkg/logger" "github.com/sipeed/picoclaw/pkg/providers" - "github.com/sipeed/picoclaw/pkg/routing" "github.com/sipeed/picoclaw/pkg/session" "github.com/sipeed/picoclaw/pkg/tools" ) @@ -332,7 +331,7 @@ func (al *AgentLoop) agentForSession(sessionKey string) *AgentInstance { return agent } - if parsed := routing.ParseAgentSessionKey(sessionKey); parsed != nil { + if parsed := session.ParseLegacyAgentSessionKey(sessionKey); parsed != nil { if agent, ok := registry.GetAgent(parsed.AgentID); ok { return agent } diff --git a/pkg/agent/steering_test.go b/pkg/agent/steering_test.go index b67ec006c..9ecd8472a 100644 --- a/pkg/agent/steering_test.go +++ b/pkg/agent/steering_test.go @@ -366,14 +366,13 @@ func TestDrainBusToSteering_RequeuesDifferentScopeMessage(t *testing.T) { al := NewAgentLoop(cfg, msgBus, &mockProvider{}) activeMsg := bus.InboundMessage{ - Channel: "telegram", - SenderID: "user1", - ChatID: "chat1", - Content: "active turn", - Peer: bus.Peer{ - Kind: "direct", - ID: "user1", + Context: bus.InboundContext{ + Channel: "telegram", + ChatID: "chat1", + ChatType: "direct", + SenderID: "user1", }, + Content: "active turn", } activeScope, activeAgentID, ok := al.resolveSteeringTarget(activeMsg) if !ok { @@ -381,14 +380,13 @@ func TestDrainBusToSteering_RequeuesDifferentScopeMessage(t *testing.T) { } otherMsg := bus.InboundMessage{ - Channel: "telegram", - SenderID: "user2", - ChatID: "chat2", - Content: "other session", - Peer: bus.Peer{ - Kind: "direct", - ID: "user2", + Context: bus.InboundContext{ + Channel: "telegram", + ChatID: "chat2", + ChatType: "direct", + SenderID: "user2", }, + Content: "other session", } otherScope, _, ok := al.resolveSteeringTarget(otherMsg) if !ok { @@ -425,7 +423,7 @@ func TestDrainBusToSteering_RequeuesDifferentScopeMessage(t *testing.T) { case <-ctx.Done(): t.Fatalf("timeout waiting for requeued message on outbound bus") case requeued := <-msgBus.OutboundChan(): - if requeued.Channel != otherMsg.Channel || requeued.ChatID != otherMsg.ChatID || + if requeued.Context.Channel != otherMsg.Context.Channel || requeued.Context.ChatID != otherMsg.Context.ChatID || requeued.Content != otherMsg.Content { t.Fatalf("requeued message mismatch: got %+v want %+v", requeued, otherMsg) } @@ -842,24 +840,22 @@ func TestAgentLoop_Run_AutoContinuesLateSteeringMessage(t *testing.T) { }() first := bus.InboundMessage{ - Channel: "test", - SenderID: "user1", - ChatID: "chat1", - Content: "first message", - Peer: bus.Peer{ - Kind: "direct", - ID: "user1", + Context: bus.InboundContext{ + Channel: "test", + ChatID: "chat1", + ChatType: "direct", + SenderID: "user1", }, + Content: "first message", } late := bus.InboundMessage{ - Channel: "test", - SenderID: "user1", - ChatID: "chat1", - Content: "late append", - Peer: bus.Peer{ - Kind: "direct", - ID: "user1", + Context: bus.InboundContext{ + Channel: "test", + ChatID: "chat1", + ChatType: "direct", + SenderID: "user1", }, + Content: "late append", } pubCtx, pubCancel := context.WithTimeout(context.Background(), 2*time.Second) @@ -950,7 +946,7 @@ func TestAgentLoop_Steering_DirectResponseContinuesWithQueuedMessage(t *testing. }, } - sessionKey := routing.BuildAgentMainSessionKey(routing.DefaultAgentID) + sessionKey := session.BuildMainSessionKey(routing.DefaultAgentID) provider := &blockingDirectProvider{ firstStarted: make(chan struct{}), releaseFirst: make(chan struct{}), @@ -1117,7 +1113,7 @@ func TestAgentLoop_Continue_PreservesSteeringMedia(t *testing.T) { }, } - sessionKey := routing.BuildAgentMainSessionKey(routing.DefaultAgentID) + sessionKey := session.BuildMainSessionKey(routing.DefaultAgentID) msgBus := bus.NewMessageBus() al := NewAgentLoop(cfg, msgBus, provider) al.SetMediaStore(store) @@ -1225,7 +1221,7 @@ func TestAgentLoop_InterruptGraceful_UsesTerminalNoToolCall(t *testing.T) { al := NewAgentLoop(cfg, msgBus, provider) al.RegisterTool(tool1) al.RegisterTool(tool2) - sessionKey := routing.BuildAgentMainSessionKey(routing.DefaultAgentID) + sessionKey := session.BuildMainSessionKey(routing.DefaultAgentID) sub := al.SubscribeEvents(32) defer al.UnsubscribeEvents(sub.ID) @@ -1379,7 +1375,7 @@ func TestAgentLoop_InterruptHard_RestoresSession(t *testing.T) { al := NewAgentLoop(cfg, msgBus, provider) started := make(chan struct{}) al.RegisterTool(&interruptibleTool{name: "cancel_tool", started: started}) - sessionKey := routing.BuildAgentMainSessionKey(routing.DefaultAgentID) + sessionKey := session.BuildMainSessionKey(routing.DefaultAgentID) defaultAgent := al.registry.GetDefaultAgent() if defaultAgent == nil { diff --git a/pkg/bus/bus.go b/pkg/bus/bus.go index 3e7ec9cdc..45e755673 100644 --- a/pkg/bus/bus.go +++ b/pkg/bus/bus.go @@ -12,6 +12,12 @@ import ( // ErrBusClosed is returned when publishing to a closed MessageBus. var ErrBusClosed = errors.New("message bus closed") +var ( + ErrMissingInboundContext = errors.New("inbound message context is required") + ErrMissingOutboundContext = errors.New("outbound message context is required") + ErrMissingOutboundMediaContext = errors.New("outbound media context is required") +) + const defaultBusBufferSize = 64 // StreamDelegate is implemented by the channel Manager to provide streaming @@ -80,6 +86,9 @@ func publish[T any](ctx context.Context, mb *MessageBus, ch chan T, msg T) error } func (mb *MessageBus) PublishInbound(ctx context.Context, msg InboundMessage) error { + if msg.Context.isZero() { + return ErrMissingInboundContext + } msg = NormalizeInboundMessage(msg) return publish(ctx, mb, mb.inbound, msg) } @@ -89,6 +98,9 @@ func (mb *MessageBus) InboundChan() <-chan InboundMessage { } func (mb *MessageBus) PublishOutbound(ctx context.Context, msg OutboundMessage) error { + if msg.Context.isZero() { + return ErrMissingOutboundContext + } msg = NormalizeOutboundMessage(msg) return publish(ctx, mb, mb.outbound, msg) } @@ -98,6 +110,9 @@ func (mb *MessageBus) OutboundChan() <-chan OutboundMessage { } func (mb *MessageBus) PublishOutboundMedia(ctx context.Context, msg OutboundMediaMessage) error { + if msg.Context.isZero() { + return ErrMissingOutboundMediaContext + } msg = NormalizeOutboundMediaMessage(msg) return publish(ctx, mb, mb.outboundMedia, msg) } diff --git a/pkg/bus/bus_test.go b/pkg/bus/bus_test.go index 087c0a65e..18d1d1df8 100644 --- a/pkg/bus/bus_test.go +++ b/pkg/bus/bus_test.go @@ -14,10 +14,13 @@ func TestPublishConsume(t *testing.T) { ctx := context.Background() msg := InboundMessage{ - Channel: "test", - SenderID: "user1", - ChatID: "chat1", - Content: "hello", + Context: InboundContext{ + Channel: "test", + ChatID: "chat1", + ChatType: "direct", + SenderID: "user1", + }, + Content: "hello", } if err := mb.PublishInbound(ctx, msg); err != nil { @@ -45,25 +48,25 @@ func TestPublishConsume(t *testing.T) { } } -func TestPublishInbound_NormalizesLegacyFieldsIntoContext(t *testing.T) { +func TestPublishInbound_NormalizesContext(t *testing.T) { mb := NewMessageBus() defer mb.Close() msg := InboundMessage{ - Channel: "slack", - SenderID: "U123", - ChatID: "C456/1712", - Content: "hello", - MessageID: "1712.01", - Peer: Peer{Kind: "group", ID: "C456"}, - Metadata: map[string]string{ - "account_id": "workspace-a", - "team_id": "T001", - "reply_to_message_id": "1700.01", - "is_mentioned": "true", - "parent_peer_kind": "topic", - "parent_peer_id": "1712", + Context: InboundContext{ + Channel: "slack", + Account: "workspace-a", + ChatID: "C456/1712", + ChatType: "group", + TopicID: "1712", + SpaceID: "T001", + SpaceType: "team", + SenderID: "U123", + MessageID: "1712.01", + ReplyToMessageID: "1700.01", + Mentioned: true, }, + Content: "hello", } if err := mb.PublishInbound(context.Background(), msg); err != nil { @@ -94,7 +97,7 @@ func TestPublishInbound_NormalizesLegacyFieldsIntoContext(t *testing.T) { } } -func TestPublishInbound_MirrorsContextIntoLegacyFields(t *testing.T) { +func TestPublishInbound_MirrorsContextIntoConvenienceFields(t *testing.T) { mb := NewMessageBus() defer mb.Close() @@ -132,27 +135,8 @@ func TestPublishInbound_MirrorsContextIntoLegacyFields(t *testing.T) { if got.MessageID != "777" { t.Fatalf("expected legacy message ID 777, got %q", got.MessageID) } - if got.Peer.Kind != "group" || got.Peer.ID != "-1001" { - t.Fatalf("expected legacy peer group/-1001, got %q/%q", got.Peer.Kind, got.Peer.ID) - } - if got.Metadata["account_id"] != "bot-a" { - t.Fatalf("expected mirrored account_id bot-a, got %q", got.Metadata["account_id"]) - } - if got.Metadata["guild_id"] != "guild-9" { - t.Fatalf("expected mirrored guild_id guild-9, got %q", got.Metadata["guild_id"]) - } - if got.Metadata["parent_peer_kind"] != "topic" || got.Metadata["parent_peer_id"] != "42" { - t.Fatalf( - "expected mirrored topic parent peer, got %q/%q", - got.Metadata["parent_peer_kind"], - got.Metadata["parent_peer_id"], - ) - } - if got.Metadata["reply_to_message_id"] != "666" { - t.Fatalf("expected mirrored reply_to_message_id 666, got %q", got.Metadata["reply_to_message_id"]) - } - if got.Metadata["is_mentioned"] != "true" { - t.Fatalf("expected mirrored is_mentioned true, got %q", got.Metadata["is_mentioned"]) + if got.Context.Account != "bot-a" || got.Context.SpaceID != "guild-9" || got.Context.TopicID != "42" { + t.Fatalf("unexpected normalized context: %+v", got.Context) } } @@ -163,8 +147,10 @@ func TestPublishOutboundSubscribe(t *testing.T) { ctx := context.Background() msg := OutboundMessage{ - Channel: "telegram", - ChatID: "123", + Context: InboundContext{ + Channel: "telegram", + ChatID: "123", + }, Content: "world", } @@ -179,6 +165,9 @@ func TestPublishOutboundSubscribe(t *testing.T) { if got.Content != "world" { t.Fatalf("expected content 'world', got %q", got.Content) } + if got.Context.Channel != "telegram" || got.Context.ChatID != "123" { + t.Fatalf("expected normalized outbound context, got %+v", got.Context) + } } func TestPublishOutbound_MirrorsContextToLegacyFields(t *testing.T) { @@ -241,6 +230,19 @@ func TestPublishOutboundMedia_MirrorsContextToLegacyFields(t *testing.T) { } } +func TestNewOutboundContext_NormalizesReplyAddress(t *testing.T) { + ctx := NewOutboundContext(" telegram ", " chat-42 ", " msg-9 ") + if ctx.Channel != "telegram" { + t.Fatalf("expected channel telegram, got %q", ctx.Channel) + } + if ctx.ChatID != "chat-42" { + t.Fatalf("expected chat_id chat-42, got %q", ctx.ChatID) + } + if ctx.ReplyToMessageID != "msg-9" { + t.Fatalf("expected reply_to_message_id msg-9, got %q", ctx.ReplyToMessageID) + } +} + func TestPublishInbound_ContextCancel(t *testing.T) { mb := NewMessageBus() defer mb.Close() @@ -248,7 +250,15 @@ func TestPublishInbound_ContextCancel(t *testing.T) { // Fill the buffer ctx := context.Background() for i := range defaultBusBufferSize { - if err := mb.PublishInbound(ctx, InboundMessage{Content: "fill"}); err != nil { + if err := mb.PublishInbound(ctx, InboundMessage{ + Context: InboundContext{ + Channel: "test", + ChatID: "chat-fill", + ChatType: "direct", + SenderID: "user-fill", + }, + Content: "fill", + }); err != nil { t.Fatalf("fill failed at %d: %v", i, err) } } @@ -257,7 +267,15 @@ func TestPublishInbound_ContextCancel(t *testing.T) { cancelCtx, cancel := context.WithCancel(context.Background()) cancel() - err := mb.PublishInbound(cancelCtx, InboundMessage{Content: "overflow"}) + err := mb.PublishInbound(cancelCtx, InboundMessage{ + Context: InboundContext{ + Channel: "test", + ChatID: "chat-overflow", + ChatType: "direct", + SenderID: "user-overflow", + }, + Content: "overflow", + }) if err == nil { t.Fatal("expected error from canceled context, got nil") } @@ -270,7 +288,15 @@ func TestPublishInbound_BusClosed(t *testing.T) { mb := NewMessageBus() mb.Close() - err := mb.PublishInbound(context.Background(), InboundMessage{Content: "test"}) + err := mb.PublishInbound(context.Background(), InboundMessage{ + Context: InboundContext{ + Channel: "test", + ChatID: "chat1", + ChatType: "direct", + SenderID: "user1", + }, + Content: "test", + }) if err != ErrBusClosed { t.Fatalf("expected ErrBusClosed, got %v", err) } @@ -280,7 +306,13 @@ func TestPublishOutbound_BusClosed(t *testing.T) { mb := NewMessageBus() mb.Close() - err := mb.PublishOutbound(context.Background(), OutboundMessage{Content: "test"}) + err := mb.PublishOutbound(context.Background(), OutboundMessage{ + Context: InboundContext{ + Channel: "test", + ChatID: "chat1", + }, + Content: "test", + }) if err != ErrBusClosed { t.Fatalf("expected ErrBusClosed, got %v", err) } @@ -292,14 +324,30 @@ func TestConsumeInbound_ContextCancel(t *testing.T) { defer mb.Close() for i := range defaultBusBufferSize { - if err := mb.PublishInbound(context.Background(), InboundMessage{Content: "fill"}); err != nil { + if err := mb.PublishInbound(context.Background(), InboundMessage{ + Context: InboundContext{ + Channel: "test", + ChatID: "chat-fill", + ChatType: "direct", + SenderID: "user-fill", + }, + Content: "fill", + }); err != nil { t.Fatalf("fill failed at %d: %v", i, err) } } ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond) defer cancel() - mb.PublishInbound(ctx, InboundMessage{Content: "ContextCancel"}) + mb.PublishInbound(ctx, InboundMessage{ + Context: InboundContext{ + Channel: "test", + ChatID: "chat-cancel", + ChatType: "direct", + SenderID: "user-cancel", + }, + Content: "ContextCancel", + }) select { case <-ctx.Done(): @@ -393,7 +441,15 @@ func TestPublishInbound_FullBuffer(t *testing.T) { // Fill the buffer for i := range defaultBusBufferSize { - if err := mb.PublishInbound(ctx, InboundMessage{Content: "fill"}); err != nil { + if err := mb.PublishInbound(ctx, InboundMessage{ + Context: InboundContext{ + Channel: "test", + ChatID: "chat-fill", + ChatType: "direct", + SenderID: "user-fill", + }, + Content: "fill", + }); err != nil { t.Fatalf("fill failed at %d: %v", i, err) } } @@ -402,7 +458,15 @@ func TestPublishInbound_FullBuffer(t *testing.T) { timeoutCtx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond) defer cancel() - err := mb.PublishInbound(timeoutCtx, InboundMessage{Content: "overflow"}) + err := mb.PublishInbound(timeoutCtx, InboundMessage{ + Context: InboundContext{ + Channel: "test", + ChatID: "chat-overflow", + ChatType: "direct", + SenderID: "user-overflow", + }, + Content: "overflow", + }) if err == nil { t.Fatal("expected error when buffer is full and context times out") } @@ -420,7 +484,15 @@ func TestCloseIdempotent(t *testing.T) { mb.Close() // After close, publish should return ErrBusClosed - err := mb.PublishInbound(context.Background(), InboundMessage{Content: "test"}) + err := mb.PublishInbound(context.Background(), InboundMessage{ + Context: InboundContext{ + Channel: "test", + ChatID: "chat1", + ChatType: "direct", + SenderID: "user1", + }, + Content: "test", + }) if err != ErrBusClosed { t.Fatalf("expected ErrBusClosed after multiple closes, got %v", err) } diff --git a/pkg/bus/inbound_context.go b/pkg/bus/inbound_context.go index 501f27be4..3a19ac957 100644 --- a/pkg/bus/inbound_context.go +++ b/pkg/bus/inbound_context.go @@ -2,92 +2,19 @@ package bus import "strings" -const ( - metadataKeyAccountID = "account_id" - metadataKeyGuildID = "guild_id" - metadataKeyTeamID = "team_id" - metadataKeyReplyToMessage = "reply_to_message_id" - metadataKeyReplyToSender = "reply_to_sender_id" - metadataKeyParentPeerKind = "parent_peer_kind" - metadataKeyParentPeerID = "parent_peer_id" - metadataKeyIsMentioned = "is_mentioned" -) - -// ContextFromLegacyInbound builds a normalized inbound context from the legacy -// top-level fields on InboundMessage. This keeps older producers working while -// new producers migrate to writing Context directly. -func ContextFromLegacyInbound(msg InboundMessage) InboundContext { - ctx := InboundContext{ - Channel: strings.TrimSpace(msg.Channel), - ChatID: strings.TrimSpace(msg.ChatID), - ChatType: normalizeKind(msg.Peer.Kind), - SenderID: firstNonEmpty( - strings.TrimSpace(msg.SenderID), - strings.TrimSpace(msg.Sender.CanonicalID), - strings.TrimSpace(msg.Sender.PlatformID), - ), - MessageID: strings.TrimSpace(msg.MessageID), - Raw: cloneStringMap(msg.Metadata), - } - - if account := metadataValue(msg.Metadata, metadataKeyAccountID); account != "" { - ctx.Account = account - } - if replyToMsgID := metadataValue(msg.Metadata, metadataKeyReplyToMessage); replyToMsgID != "" { - ctx.ReplyToMessageID = replyToMsgID - } - if replyToSenderID := metadataValue(msg.Metadata, metadataKeyReplyToSender); replyToSenderID != "" { - ctx.ReplyToSenderID = replyToSenderID - } - if isTruthy(metadataValue(msg.Metadata, metadataKeyIsMentioned)) { - ctx.Mentioned = true - } - - parentKind := normalizeKind(metadataValue(msg.Metadata, metadataKeyParentPeerKind)) - parentID := metadataValue(msg.Metadata, metadataKeyParentPeerID) - if parentKind == "topic" && parentID != "" { - ctx.TopicID = parentID - } - - switch { - case metadataValue(msg.Metadata, metadataKeyGuildID) != "": - ctx.SpaceType = "guild" - ctx.SpaceID = metadataValue(msg.Metadata, metadataKeyGuildID) - case metadataValue(msg.Metadata, metadataKeyTeamID) != "": - ctx.SpaceType = "team" - ctx.SpaceID = metadataValue(msg.Metadata, metadataKeyTeamID) - } - - return normalizeInboundContext(ctx) -} - -// NormalizeInboundMessage ensures the normalized Context is present and mirrors -// missing legacy fields from it so older consumers continue to work during the -// migration period. +// NormalizeInboundMessage ensures the inbound context is normalized and keeps +// convenience mirrors in sync for runtime consumers. func NormalizeInboundMessage(msg InboundMessage) InboundMessage { - if msg.Context.isZero() { - msg.Context = ContextFromLegacyInbound(msg) - } else { - msg.Context = normalizeInboundContext(msg.Context) - } - - if msg.Channel == "" { - msg.Channel = msg.Context.Channel - } - if msg.SenderID == "" { - msg.SenderID = msg.Context.SenderID - } - if msg.ChatID == "" { - msg.ChatID = msg.Context.ChatID - } + msg.Context = normalizeInboundContext(msg.Context) + msg.Channel = msg.Context.Channel + msg.SenderID = msg.Context.SenderID + msg.ChatID = msg.Context.ChatID if msg.MessageID == "" { msg.MessageID = msg.Context.MessageID } - if msg.Peer.Kind == "" { - msg.Peer = peerFromContext(msg.Context) + if msg.Context.MessageID == "" { + msg.Context.MessageID = msg.MessageID } - - msg.Metadata = mergeLegacyMetadata(msg.Metadata, msg.Context) return msg } @@ -125,110 +52,6 @@ func normalizeInboundContext(ctx InboundContext) InboundContext { return ctx } -func peerFromContext(ctx InboundContext) Peer { - kind := normalizeKind(ctx.ChatType) - if kind == "" { - return Peer{} - } - - switch kind { - case "direct": - return Peer{ - Kind: "direct", - ID: firstNonEmpty(strings.TrimSpace(ctx.SenderID), strings.TrimSpace(ctx.ChatID)), - } - case "group", "channel": - return Peer{ - Kind: kind, - ID: strings.TrimSpace(ctx.ChatID), - } - default: - return Peer{ - Kind: kind, - ID: strings.TrimSpace(ctx.ChatID), - } - } -} - -func mergeLegacyMetadata(existing map[string]string, ctx InboundContext) map[string]string { - merged := cloneStringMap(existing) - if len(merged) == 0 { - merged = cloneStringMap(ctx.Raw) - } else { - for k, v := range ctx.Raw { - if _, ok := merged[k]; !ok { - merged[k] = v - } - } - } - - if ctx.Account != "" { - if merged == nil { - merged = make(map[string]string) - } - setMissing(merged, metadataKeyAccountID, ctx.Account) - } - if ctx.ReplyToMessageID != "" { - if merged == nil { - merged = make(map[string]string) - } - setMissing(merged, metadataKeyReplyToMessage, ctx.ReplyToMessageID) - } - if ctx.ReplyToSenderID != "" { - if merged == nil { - merged = make(map[string]string) - } - setMissing(merged, metadataKeyReplyToSender, ctx.ReplyToSenderID) - } - if ctx.Mentioned { - if merged == nil { - merged = make(map[string]string) - } - setMissing(merged, metadataKeyIsMentioned, "true") - } - if ctx.TopicID != "" { - if merged == nil { - merged = make(map[string]string) - } - setMissing(merged, metadataKeyParentPeerKind, "topic") - setMissing(merged, metadataKeyParentPeerID, ctx.TopicID) - } - - switch normalizeKind(ctx.SpaceType) { - case "guild": - if merged == nil { - merged = make(map[string]string) - } - setMissing(merged, metadataKeyGuildID, ctx.SpaceID) - case "team", "workspace": - if merged == nil { - merged = make(map[string]string) - } - setMissing(merged, metadataKeyTeamID, ctx.SpaceID) - } - - if len(merged) == 0 { - return nil - } - return merged -} - -func setMissing(dst map[string]string, key, value string) { - if value == "" { - return - } - if _, ok := dst[key]; !ok { - dst[key] = value - } -} - -func metadataValue(metadata map[string]string, key string) string { - if metadata == nil { - return "" - } - return strings.TrimSpace(metadata[key]) -} - func cloneStringMap(src map[string]string) map[string]string { if len(src) == 0 { return nil @@ -241,24 +64,11 @@ func cloneStringMap(src map[string]string) map[string]string { return dst } -func firstNonEmpty(values ...string) string { - for _, value := range values { - if value != "" { - return value - } - } - return "" -} - -func normalizeKind(value string) string { - return strings.ToLower(strings.TrimSpace(value)) -} - -func isTruthy(value string) bool { - switch strings.ToLower(strings.TrimSpace(value)) { - case "1", "t", "true", "y", "yes", "on": - return true +func normalizeKind(kind string) string { + switch strings.ToLower(strings.TrimSpace(kind)) { + case "direct", "group", "channel", "guild", "team", "workspace", "tenant", "topic": + return strings.ToLower(strings.TrimSpace(kind)) default: - return false + return strings.ToLower(strings.TrimSpace(kind)) } } diff --git a/pkg/bus/outbound_context.go b/pkg/bus/outbound_context.go index e02353ea9..b3f58f736 100644 --- a/pkg/bus/outbound_context.go +++ b/pkg/bus/outbound_context.go @@ -2,62 +2,34 @@ package bus import "strings" -// ContextFromLegacyOutbound builds a minimal outbound context from the legacy -// top-level outbound fields. This keeps older outbound publishers working -// while new publishers gradually start carrying the original InboundContext. -func ContextFromLegacyOutbound(msg OutboundMessage) InboundContext { +// NewOutboundContext builds the minimal normalized addressing context required +// to deliver an outbound text message or reply. +func NewOutboundContext(channel, chatID, replyToMessageID string) InboundContext { return normalizeInboundContext(InboundContext{ - Channel: strings.TrimSpace(msg.Channel), - ChatID: strings.TrimSpace(msg.ChatID), - ReplyToMessageID: strings.TrimSpace(msg.ReplyToMessageID), + Channel: strings.TrimSpace(channel), + ChatID: strings.TrimSpace(chatID), + ReplyToMessageID: strings.TrimSpace(replyToMessageID), }) } -// ContextFromLegacyOutboundMedia builds a minimal outbound context for media. -func ContextFromLegacyOutboundMedia(msg OutboundMediaMessage) InboundContext { - return normalizeInboundContext(InboundContext{ - Channel: strings.TrimSpace(msg.Channel), - ChatID: strings.TrimSpace(msg.ChatID), - }) -} - -// NormalizeOutboundMessage ensures Context is present and mirrors legacy -// top-level addressing fields from it so older senders keep working. +// NormalizeOutboundMessage ensures Context is normalized and keeps convenience +// mirrors in sync for runtime consumers. func NormalizeOutboundMessage(msg OutboundMessage) OutboundMessage { - if msg.Context.isZero() { - msg.Context = ContextFromLegacyOutbound(msg) - } else { - msg.Context = normalizeInboundContext(msg.Context) + msg.Context = normalizeInboundContext(msg.Context) + msg.Channel = msg.Context.Channel + msg.ChatID = msg.Context.ChatID + if msg.Context.ReplyToMessageID == "" { + msg.Context.ReplyToMessageID = strings.TrimSpace(msg.ReplyToMessageID) } - - if msg.Channel == "" { - msg.Channel = msg.Context.Channel - } - if msg.ChatID == "" { - msg.ChatID = msg.Context.ChatID - } - if msg.ReplyToMessageID == "" { - msg.ReplyToMessageID = msg.Context.ReplyToMessageID - } - + msg.ReplyToMessageID = msg.Context.ReplyToMessageID return msg } // NormalizeOutboundMediaMessage ensures media outbound messages also carry a -// normalized context while preserving the legacy top-level routing fields. +// normalized context while keeping convenience mirrors in sync. func NormalizeOutboundMediaMessage(msg OutboundMediaMessage) OutboundMediaMessage { - if msg.Context.isZero() { - msg.Context = ContextFromLegacyOutboundMedia(msg) - } else { - msg.Context = normalizeInboundContext(msg.Context) - } - - if msg.Channel == "" { - msg.Channel = msg.Context.Channel - } - if msg.ChatID == "" { - msg.ChatID = msg.Context.ChatID - } - + msg.Context = normalizeInboundContext(msg.Context) + msg.Channel = msg.Context.Channel + msg.ChatID = msg.Context.ChatID return msg } diff --git a/pkg/bus/types.go b/pkg/bus/types.go index f844ab1e0..cccfc8baf 100644 --- a/pkg/bus/types.go +++ b/pkg/bus/types.go @@ -1,11 +1,5 @@ package bus -// Peer identifies the routing peer for a message (direct, group, channel, etc.) -type Peer struct { - Kind string `json:"kind"` // "direct" | "group" | "channel" | "" - ID string `json:"id"` -} - // SenderInfo provides structured sender identity information. type SenderInfo struct { Platform string `json:"platform,omitempty"` // "telegram", "discord", "slack", ... @@ -16,9 +10,8 @@ type SenderInfo struct { } // InboundContext captures the normalized, platform-agnostic facts about an -// inbound message. This is the long-term source of truth for routing and -// session allocation. Legacy top-level fields on InboundMessage remain during -// the transition and are derived from this context when missing. +// inbound message. This is the source of truth for routing and session +// allocation. type InboundContext struct { Channel string `json:"channel"` Account string `json:"account,omitempty"` @@ -43,18 +36,18 @@ type InboundContext struct { } type InboundMessage struct { - Channel string `json:"channel"` - SenderID string `json:"sender_id"` - Sender SenderInfo `json:"sender"` - ChatID string `json:"chat_id"` - Context InboundContext `json:"context"` - Content string `json:"content"` - Media []string `json:"media,omitempty"` - Peer Peer `json:"peer"` // routing peer - MessageID string `json:"message_id,omitempty"` // platform message ID - MediaScope string `json:"media_scope,omitempty"` // media lifecycle scope - SessionKey string `json:"session_key"` - Metadata map[string]string `json:"metadata,omitempty"` + Context InboundContext `json:"context"` + Sender SenderInfo `json:"sender"` + Content string `json:"content"` + Media []string `json:"media,omitempty"` + MediaScope string `json:"media_scope,omitempty"` // media lifecycle scope + SessionKey string `json:"session_key"` + + // Convenience mirrors derived from Context for runtime consumers. + Channel string `json:"channel"` + SenderID string `json:"sender_id"` + ChatID string `json:"chat_id"` + MessageID string `json:"message_id,omitempty"` // platform message ID } type OutboundMessage struct { diff --git a/pkg/channels/base.go b/pkg/channels/base.go index 8161fa12e..37fce7cb6 100644 --- a/pkg/channels/base.go +++ b/pkg/channels/base.go @@ -244,35 +244,8 @@ func (c *BaseChannel) IsAllowedSender(sender bus.SenderInfo) bool { return false } -func (c *BaseChannel) HandleMessage( - ctx context.Context, - peer bus.Peer, - messageID, senderID, chatID, content string, - media []string, - metadata map[string]string, - senderOpts ...bus.SenderInfo, -) { - var sender bus.SenderInfo - if len(senderOpts) > 0 { - sender = senderOpts[0] - } - - inboundCtx := bus.ContextFromLegacyInbound(bus.InboundMessage{ - Channel: c.name, - SenderID: senderID, - Sender: sender, - ChatID: chatID, - Peer: peer, - MessageID: messageID, - Metadata: metadata, - }) - - c.HandleMessageWithContext(ctx, peer, chatID, content, media, inboundCtx, senderOpts...) -} - func (c *BaseChannel) HandleMessageWithContext( ctx context.Context, - peer bus.Peer, deliveryChatID, content string, media []string, inboundCtx bus.InboundContext, @@ -315,15 +288,10 @@ func (c *BaseChannel) HandleMessageWithContext( scope := BuildMediaScope(c.name, deliveryChatID, inboundCtx.MessageID) msg := bus.InboundMessage{ - Channel: c.name, - SenderID: resolvedSenderID, - Sender: sender, - ChatID: deliveryChatID, Context: inboundCtx, + Sender: sender, Content: content, Media: media, - Peer: peer, - MessageID: inboundCtx.MessageID, MediaScope: scope, } msg = bus.NormalizeInboundMessage(msg) @@ -369,6 +337,18 @@ func (c *BaseChannel) HandleMessageWithContext( } } +// HandleInboundContext publishes a normalized inbound message using only the +// structured context. +func (c *BaseChannel) HandleInboundContext( + ctx context.Context, + deliveryChatID, content string, + media []string, + inboundCtx bus.InboundContext, + senderOpts ...bus.SenderInfo, +) { + c.HandleMessageWithContext(ctx, deliveryChatID, content, media, inboundCtx, senderOpts...) +} + func (c *BaseChannel) SetRunning(running bool) { c.running.Store(running) } diff --git a/pkg/channels/base_test.go b/pkg/channels/base_test.go index 6132b8bf9..04500f775 100644 --- a/pkg/channels/base_test.go +++ b/pkg/channels/base_test.go @@ -1,6 +1,7 @@ package channels import ( + "context" "testing" "github.com/sipeed/picoclaw/pkg/bus" @@ -263,3 +264,58 @@ func TestIsAllowedSender(t *testing.T) { }) } } + +func TestHandleInboundContext_PublishesNormalizedContext(t *testing.T) { + tests := []struct { + name string + inbound bus.InboundContext + wantChat string + wantSender string + }{ + { + name: "direct uses sender as peer", + inbound: bus.InboundContext{ + Channel: "test", + ChatID: "chat-1", + ChatType: "direct", + SenderID: "user-1", + MessageID: "msg-1", + }, + wantChat: "chat-1", + wantSender: "user-1", + }, + { + name: "group uses chat as peer", + inbound: bus.InboundContext{ + Channel: "test", + ChatID: "group-1", + ChatType: "group", + SenderID: "user-2", + MessageID: "msg-2", + }, + wantChat: "group-1", + wantSender: "user-2", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + msgBus := bus.NewMessageBus() + defer msgBus.Close() + + ch := NewBaseChannel("test", nil, msgBus, nil) + ch.HandleInboundContext(context.Background(), tt.inbound.ChatID, "hello", nil, tt.inbound) + + msg := <-msgBus.InboundChan() + if msg.ChatID != tt.wantChat { + t.Fatalf("ChatID = %q, want %q", msg.ChatID, tt.wantChat) + } + if msg.SenderID != tt.wantSender { + t.Fatalf("SenderID = %q, want %q", msg.SenderID, tt.wantSender) + } + if msg.Context.ChatType != tt.inbound.ChatType { + t.Fatalf("ChatType = %q, want %q", msg.Context.ChatType, tt.inbound.ChatType) + } + }) + } +} diff --git a/pkg/channels/dingtalk/dingtalk.go b/pkg/channels/dingtalk/dingtalk.go index 04ccec8a2..30dfffad9 100644 --- a/pkg/channels/dingtalk/dingtalk.go +++ b/pkg/channels/dingtalk/dingtalk.go @@ -181,16 +181,15 @@ func (c *DingTalkChannel) onChatBotMessageReceived( "session_webhook": data.SessionWebhook, } - var peer bus.Peer + var ( + chatType string + isMentioned bool + ) if data.ConversationType == "1" { - peerID := senderID - if peerID == "" { - peerID = chatID - } - peer = bus.Peer{Kind: "direct", ID: peerID} + chatType = "direct" } else { - peer = bus.Peer{Kind: "group", ID: data.ConversationId} - isMentioned := data.IsInAtList + chatType = "group" + isMentioned = data.IsInAtList if isMentioned { content = stripLeadingAtMentions(content) } @@ -228,8 +227,21 @@ func (c *DingTalkChannel) onChatBotMessageReceived( return nil, nil } - // Handle the message through the base channel - c.HandleMessage(ctx, peer, "", resolvedSenderID, chatID, content, nil, metadata, sender) + inboundCtx := bus.InboundContext{ + Channel: "dingtalk", + ChatID: chatID, + ChatType: chatType, + SenderID: resolvedSenderID, + Mentioned: isMentioned, + Raw: metadata, + } + if data.SessionWebhook != "" { + inboundCtx.ReplyHandles = map[string]string{ + "session_webhook": data.SessionWebhook, + } + } + + c.HandleInboundContext(ctx, chatID, content, nil, inboundCtx, sender) // Return nil to indicate we've handled the message asynchronously // The response will be sent through the message bus diff --git a/pkg/channels/discord/discord.go b/pkg/channels/discord/discord.go index 0376dcdae..427d20779 100644 --- a/pkg/channels/discord/discord.go +++ b/pkg/channels/discord/discord.go @@ -461,14 +461,10 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag }) peerKind := "channel" - peerID := m.ChannelID if m.GuildID == "" { peerKind = "direct" - peerID = senderID } - peer := bus.Peer{Kind: peerKind, ID: peerID} - metadata := map[string]string{ "user_id": senderID, "username": m.Author.Username, @@ -494,7 +490,7 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag inboundCtx.ReplyToMessageID = m.MessageReference.MessageID } - c.HandleMessageWithContext(c.ctx, peer, m.ChannelID, content, mediaPaths, inboundCtx, sender) + c.HandleInboundContext(c.ctx, m.ChannelID, content, mediaPaths, inboundCtx, sender) } // startTyping starts a continuous typing indicator loop for the given chatID. diff --git a/pkg/channels/feishu/feishu_64.go b/pkg/channels/feishu/feishu_64.go index b0b231d09..f74fab19b 100644 --- a/pkg/channels/feishu/feishu_64.go +++ b/pkg/channels/feishu/feishu_64.go @@ -447,22 +447,25 @@ func (c *FeishuChannel) handleMessageReceive(ctx context.Context, event *larkim. if messageType != "" { metadata["message_type"] = messageType } - chatType := stringValue(message.ChatType) - if chatType != "" { - metadata["chat_type"] = chatType + rawChatType := stringValue(message.ChatType) + if rawChatType != "" { + metadata["chat_type"] = rawChatType } if sender != nil && sender.TenantKey != nil { metadata["tenant_key"] = *sender.TenantKey } - var peer bus.Peer - if chatType == "p2p" { - peer = bus.Peer{Kind: "direct", ID: senderID} + var ( + inboundChatType string + isMentioned bool + ) + if rawChatType == "p2p" { + inboundChatType = "direct" } else { - peer = bus.Peer{Kind: "group", ID: chatID} + inboundChatType = "group" // Check if bot was mentioned - isMentioned := c.isBotMentioned(message) + isMentioned = c.isBotMentioned(message) // Strip mention placeholders from content before group trigger check if len(message.Mentions) > 0 { @@ -484,7 +487,21 @@ func (c *FeishuChannel) handleMessageReceive(ctx context.Context, event *larkim. "preview": utils.Truncate(content, 80), }) - c.HandleMessage(ctx, peer, messageID, senderID, chatID, content, mediaRefs, metadata, senderInfo) + inboundCtx := bus.InboundContext{ + Channel: "feishu", + ChatID: chatID, + ChatType: inboundChatType, + SenderID: senderID, + MessageID: messageID, + Mentioned: isMentioned, + Raw: metadata, + } + if sender != nil && sender.TenantKey != nil && *sender.TenantKey != "" { + inboundCtx.SpaceType = "tenant" + inboundCtx.SpaceID = *sender.TenantKey + } + + c.HandleInboundContext(ctx, chatID, content, mediaRefs, inboundCtx, senderInfo) return nil } diff --git a/pkg/channels/irc/handler.go b/pkg/channels/irc/handler.go index b92359da4..73df9c43c 100644 --- a/pkg/channels/irc/handler.go +++ b/pkg/channels/irc/handler.go @@ -51,14 +51,11 @@ func (c *IRCChannel) onPrivmsg(conn *ircevent.Connection, e ircmsg.Message) { isDM := !strings.HasPrefix(target, "#") && !strings.HasPrefix(target, "&") var chatID string - var peer bus.Peer if isDM { chatID = nick - peer = bus.Peer{Kind: "direct", ID: nick} } else { chatID = target - peer = bus.Peer{Kind: "group", ID: target} } sender := bus.SenderInfo{ @@ -73,9 +70,11 @@ func (c *IRCChannel) onPrivmsg(conn *ircevent.Connection, e ircmsg.Message) { return } + isMentioned := false + // For channel messages, check group trigger (mention detection) if !isDM { - isMentioned := isBotMentioned(content, currentNick) + isMentioned = isBotMentioned(content, currentNick) if isMentioned { content = stripBotMention(content, currentNick) } @@ -100,7 +99,21 @@ func (c *IRCChannel) onPrivmsg(conn *ircevent.Connection, e ircmsg.Message) { metadata["channel"] = target } - c.HandleMessage(c.ctx, peer, messageID, nick, chatID, content, nil, metadata, sender) + inboundCtx := bus.InboundContext{ + Channel: "irc", + ChatID: chatID, + SenderID: nick, + MessageID: messageID, + Mentioned: isMentioned, + Raw: metadata, + } + if isDM { + inboundCtx.ChatType = "direct" + } else { + inboundCtx.ChatType = "group" + } + + c.HandleInboundContext(c.ctx, chatID, content, nil, inboundCtx, sender) } // nickMentionedAt returns the byte index where botNick is mentioned in content diff --git a/pkg/channels/line/line.go b/pkg/channels/line/line.go index 269f14997..b0853fb8b 100644 --- a/pkg/channels/line/line.go +++ b/pkg/channels/line/line.go @@ -368,13 +368,6 @@ func (c *LINEChannel) processEvent(event lineEvent) { "source_type": event.Source.Type, } - var peer bus.Peer - if isGroup { - peer = bus.Peer{Kind: "group", ID: chatID} - } else { - peer = bus.Peer{Kind: "direct", ID: senderID} - } - logger.DebugCF("line", "Received message", map[string]any{ "sender_id": senderID, "chat_id": chatID, @@ -396,7 +389,7 @@ func (c *LINEChannel) processEvent(event lineEvent) { inboundCtx := bus.InboundContext{ Channel: c.Name(), ChatID: chatID, - ChatType: peer.Kind, + ChatType: map[bool]string{true: "group", false: "direct"}[isGroup], SenderID: senderID, MessageID: msg.ID, Mentioned: isMentioned, @@ -411,7 +404,7 @@ func (c *LINEChannel) processEvent(event lineEvent) { } } - c.HandleMessageWithContext(c.ctx, peer, chatID, content, mediaPaths, inboundCtx, sender) + c.HandleInboundContext(c.ctx, chatID, content, mediaPaths, inboundCtx, sender) } // isBotMentioned checks if the bot is mentioned in the message. diff --git a/pkg/channels/maixcam/maixcam.go b/pkg/channels/maixcam/maixcam.go index bbbf2da56..0c77d1392 100644 --- a/pkg/channels/maixcam/maixcam.go +++ b/pkg/channels/maixcam/maixcam.go @@ -196,17 +196,15 @@ func (c *MaixCamChannel) handlePersonDetection(msg MaixCamMessage) { return } - c.HandleMessage( - c.ctx, - bus.Peer{Kind: "channel", ID: "default"}, - "", - senderID, - chatID, - content, - []string{}, - metadata, - sender, - ) + inboundCtx := bus.InboundContext{ + Channel: "maixcam", + ChatID: chatID, + ChatType: "channel", + SenderID: senderID, + Raw: metadata, + } + + c.HandleInboundContext(c.ctx, chatID, content, nil, inboundCtx, sender) } func (c *MaixCamChannel) handleStatusUpdate(msg MaixCamMessage) { diff --git a/pkg/channels/manager.go b/pkg/channels/manager.go index 76d1e67c5..60cea9e78 100644 --- a/pkg/channels/manager.go +++ b/pkg/channels/manager.go @@ -97,6 +97,22 @@ type asyncTask struct { cancel context.CancelFunc } +func outboundMessageChannel(msg bus.OutboundMessage) string { + return msg.Context.Channel +} + +func outboundMessageChatID(msg bus.OutboundMessage) string { + return msg.Context.ChatID +} + +func outboundMediaChannel(msg bus.OutboundMediaMessage) string { + return msg.Context.Channel +} + +func outboundMediaChatID(msg bus.OutboundMediaMessage) string { + return msg.Context.ChatID +} + // RecordPlaceholder registers a placeholder message for later editing. // Implements PlaceholderRecorder. func (m *Manager) RecordPlaceholder(channel, chatID, placeholderID string) { @@ -160,7 +176,8 @@ func (m *Manager) RecordReactionUndo(channel, chatID string, undo func()) { // preSend handles typing stop, reaction undo, and placeholder editing before sending a message. // Returns the delivered message IDs and true when delivery completed before a normal Send. func (m *Manager) preSend(ctx context.Context, name string, msg bus.OutboundMessage, ch Channel) ([]string, bool) { - key := name + ":" + msg.ChatID + chatID := outboundMessageChatID(msg) + key := name + ":" + chatID // 1. Stop typing if v, loaded := m.typingStops.LoadAndDelete(key); loaded { @@ -182,9 +199,9 @@ func (m *Manager) preSend(ctx context.Context, name string, msg bus.OutboundMess if entry, ok := v.(placeholderEntry); ok && entry.id != "" { // Prefer deleting the placeholder (cleaner UX than editing to same content) if deleter, ok := ch.(MessageDeleter); ok { - deleter.DeleteMessage(ctx, msg.ChatID, entry.id) // best effort + deleter.DeleteMessage(ctx, chatID, entry.id) // best effort } else if editor, ok := ch.(MessageEditor); ok { - editor.EditMessage(ctx, msg.ChatID, entry.id, msg.Content) // fallback + editor.EditMessage(ctx, chatID, entry.id, msg.Content) // fallback } } } @@ -195,7 +212,7 @@ func (m *Manager) preSend(ctx context.Context, name string, msg bus.OutboundMess if v, loaded := m.placeholders.LoadAndDelete(key); loaded { if entry, ok := v.(placeholderEntry); ok && entry.id != "" { if editor, ok := ch.(MessageEditor); ok { - if err := editor.EditMessage(ctx, msg.ChatID, entry.id, msg.Content); err == nil { + if err := editor.EditMessage(ctx, chatID, entry.id, msg.Content); err == nil { return []string{entry.id}, true } // edit failed → fall through to normal Send @@ -211,7 +228,8 @@ func (m *Manager) preSend(ctx context.Context, name string, msg bus.OutboundMess // delivery never edits the placeholder because there is no text payload to // replace it with; it only attempts to delete the placeholder when possible. func (m *Manager) preSendMedia(ctx context.Context, name string, msg bus.OutboundMediaMessage, ch Channel) { - key := name + ":" + msg.ChatID + chatID := outboundMediaChatID(msg) + key := name + ":" + chatID // 1. Stop typing if v, loaded := m.typingStops.LoadAndDelete(key); loaded { @@ -234,7 +252,7 @@ func (m *Manager) preSendMedia(ctx context.Context, name string, msg bus.Outboun if v, loaded := m.placeholders.LoadAndDelete(key); loaded { if entry, ok := v.(placeholderEntry); ok && entry.id != "" { if deleter, ok := ch.(MessageDeleter); ok { - deleter.DeleteMessage(ctx, msg.ChatID, entry.id) // best effort + deleter.DeleteMessage(ctx, chatID, entry.id) // best effort } } } @@ -756,7 +774,7 @@ func (m *Manager) sendWithRetry( // All retries exhausted or permanent failure logger.ErrorCF("channels", "Send failed", map[string]any{ "channel": name, - "chat_id": msg.ChatID, + "chat_id": outboundMessageChatID(msg), "error": lastErr.Error(), "retries": maxRetries, }) @@ -818,7 +836,7 @@ func (m *Manager) dispatchOutbound(ctx context.Context) { dispatchLoop( ctx, m, m.bus.OutboundChan(), - func(msg bus.OutboundMessage) string { return msg.Channel }, + func(msg bus.OutboundMessage) string { return outboundMessageChannel(msg) }, func(ctx context.Context, w *channelWorker, msg bus.OutboundMessage) bool { select { case w.queue <- msg: @@ -838,7 +856,7 @@ func (m *Manager) dispatchOutboundMedia(ctx context.Context) { dispatchLoop( ctx, m, m.bus.OutboundMediaChan(), - func(msg bus.OutboundMediaMessage) string { return msg.Channel }, + func(msg bus.OutboundMediaMessage) string { return outboundMediaChannel(msg) }, func(ctx context.Context, w *channelWorker, msg bus.OutboundMediaMessage) bool { select { case w.mediaQueue <- msg: @@ -937,7 +955,7 @@ func (m *Manager) sendMediaWithRetry( // All retries exhausted or permanent failure logger.ErrorCF("channels", "SendMedia failed", map[string]any{ "channel": name, - "chat_id": msg.ChatID, + "chat_id": outboundMediaChatID(msg), "error": lastErr.Error(), "retries": maxRetries, }) @@ -1131,17 +1149,18 @@ func (m *Manager) UnregisterChannel(name string) { // a subsequent operation depends on the message having been sent. func (m *Manager) SendMessage(ctx context.Context, msg bus.OutboundMessage) error { msg = bus.NormalizeOutboundMessage(msg) + channelName := outboundMessageChannel(msg) m.mu.RLock() - _, exists := m.channels[msg.Channel] - w, wExists := m.workers[msg.Channel] + _, exists := m.channels[channelName] + w, wExists := m.workers[channelName] m.mu.RUnlock() if !exists { - return fmt.Errorf("channel %s not found", msg.Channel) + return fmt.Errorf("channel %s not found", channelName) } if !wExists || w == nil { - return fmt.Errorf("channel %s has no active worker", msg.Channel) + return fmt.Errorf("channel %s has no active worker", channelName) } maxLen := 0 @@ -1152,10 +1171,10 @@ func (m *Manager) SendMessage(ctx context.Context, msg bus.OutboundMessage) erro for _, chunk := range SplitMessage(msg.Content, maxLen) { chunkMsg := msg chunkMsg.Content = chunk - m.sendWithRetry(ctx, msg.Channel, w, chunkMsg) + m.sendWithRetry(ctx, channelName, w, chunkMsg) } } else { - m.sendWithRetry(ctx, msg.Channel, w, msg) + m.sendWithRetry(ctx, channelName, w, msg) } return nil } @@ -1166,20 +1185,21 @@ func (m *Manager) SendMessage(ctx context.Context, msg bus.OutboundMessage) erro // depends on actual media delivery. func (m *Manager) SendMedia(ctx context.Context, msg bus.OutboundMediaMessage) error { msg = bus.NormalizeOutboundMediaMessage(msg) + channelName := outboundMediaChannel(msg) m.mu.RLock() - _, exists := m.channels[msg.Channel] - w, wExists := m.workers[msg.Channel] + _, exists := m.channels[channelName] + w, wExists := m.workers[channelName] m.mu.RUnlock() if !exists { - return fmt.Errorf("channel %s not found", msg.Channel) + return fmt.Errorf("channel %s not found", channelName) } if !wExists || w == nil { - return fmt.Errorf("channel %s has no active worker", msg.Channel) + return fmt.Errorf("channel %s has no active worker", channelName) } - _, err := m.sendMediaWithRetry(ctx, msg.Channel, w, msg) + _, err := m.sendMediaWithRetry(ctx, channelName, w, msg) return err } @@ -1194,10 +1214,10 @@ func (m *Manager) SendToChannel(ctx context.Context, channelName, chatID, conten } msg := bus.OutboundMessage{ - Channel: channelName, - ChatID: chatID, + Context: bus.NewOutboundContext(channelName, chatID, ""), Content: content, } + msg = bus.NormalizeOutboundMessage(msg) if wExists && w != nil { select { diff --git a/pkg/channels/manager_test.go b/pkg/channels/manager_test.go index e76212905..29219679d 100644 --- a/pkg/channels/manager_test.go +++ b/pkg/channels/manager_test.go @@ -89,6 +89,20 @@ func newTestManager() *Manager { } } +func testOutboundMessage(msg bus.OutboundMessage) bus.OutboundMessage { + if msg.Context.Channel == "" && msg.Context.ChatID == "" { + msg.Context = bus.NewOutboundContext(msg.Channel, msg.ChatID, msg.ReplyToMessageID) + } + return bus.NormalizeOutboundMessage(msg) +} + +func testOutboundMediaMessage(msg bus.OutboundMediaMessage) bus.OutboundMediaMessage { + if msg.Context.Channel == "" && msg.Context.ChatID == "" { + msg.Context = bus.NewOutboundContext(msg.Channel, msg.ChatID, "") + } + return bus.NormalizeOutboundMediaMessage(msg) +} + func TestSendWithRetry_Success(t *testing.T) { m := newTestManager() var callCount int @@ -104,7 +118,7 @@ func TestSendWithRetry_Success(t *testing.T) { } ctx := context.Background() - msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}) m.sendWithRetry(ctx, "test", w, msg) @@ -131,7 +145,7 @@ func TestSendWithRetry_TemporaryThenSuccess(t *testing.T) { } ctx := context.Background() - msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}) m.sendWithRetry(ctx, "test", w, msg) @@ -155,7 +169,7 @@ func TestSendWithRetry_PermanentFailure(t *testing.T) { } ctx := context.Background() - msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}) m.sendWithRetry(ctx, "test", w, msg) @@ -179,7 +193,7 @@ func TestSendWithRetry_NotRunning(t *testing.T) { } ctx := context.Background() - msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}) m.sendWithRetry(ctx, "test", w, msg) @@ -206,7 +220,7 @@ func TestSendWithRetry_RateLimitRetry(t *testing.T) { } ctx := context.Background() - msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}) start := time.Now() m.sendWithRetry(ctx, "test", w, msg) @@ -236,7 +250,7 @@ func TestSendWithRetry_MaxRetriesExhausted(t *testing.T) { } ctx := context.Background() - msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}) m.sendWithRetry(ctx, "test", w, msg) @@ -262,11 +276,11 @@ func TestSendMedia_Success(t *testing.T) { m.channels["test"] = ch m.workers["test"] = w - err := m.SendMedia(context.Background(), bus.OutboundMediaMessage{ + err := m.SendMedia(context.Background(), testOutboundMediaMessage(bus.OutboundMediaMessage{ Channel: "test", ChatID: "chat1", Parts: []bus.MediaPart{{Ref: "media://abc"}}, - }) + })) if err != nil { t.Fatalf("SendMedia() error = %v", err) } @@ -289,11 +303,11 @@ func TestSendMedia_PropagatesFailure(t *testing.T) { m.channels["test"] = ch m.workers["test"] = w - err := m.SendMedia(context.Background(), bus.OutboundMediaMessage{ + err := m.SendMedia(context.Background(), testOutboundMediaMessage(bus.OutboundMediaMessage{ Channel: "test", ChatID: "chat1", Parts: []bus.MediaPart{{Ref: "media://abc"}}, - }) + })) if err == nil { t.Fatal("expected SendMedia to return error") } @@ -316,11 +330,11 @@ func TestSendMedia_UnsupportedChannelReturnsError(t *testing.T) { m.channels["test"] = ch m.workers["test"] = w - err := m.SendMedia(context.Background(), bus.OutboundMediaMessage{ + err := m.SendMedia(context.Background(), testOutboundMediaMessage(bus.OutboundMediaMessage{ Channel: "test", ChatID: "chat1", Parts: []bus.MediaPart{{Ref: "media://abc"}}, - }) + })) if err == nil { t.Fatal("expected SendMedia to return error for unsupported channel") } @@ -346,11 +360,11 @@ func TestSendMedia_DeletesPlaceholderBeforeSending(t *testing.T) { m.workers["test"] = w m.RecordPlaceholder("test", "chat1", "placeholder-1") - err := m.SendMedia(context.Background(), bus.OutboundMediaMessage{ + err := m.SendMedia(context.Background(), testOutboundMediaMessage(bus.OutboundMediaMessage{ Channel: "test", ChatID: "chat1", Parts: []bus.MediaPart{{Ref: "media://abc"}}, - }) + })) if err != nil { t.Fatalf("SendMedia() error = %v", err) } @@ -383,7 +397,7 @@ func TestSendWithRetry_UnknownError(t *testing.T) { } ctx := context.Background() - msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}) m.sendWithRetry(ctx, "test", w, msg) @@ -407,7 +421,7 @@ func TestSendWithRetry_ContextCancelled(t *testing.T) { } ctx, cancel := context.WithCancel(context.Background()) - msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}) // Cancel context after first Send attempt returns ch.sendFn = func(_ context.Context, _ bus.OutboundMessage) error { @@ -453,7 +467,7 @@ func TestWorkerRateLimiter(t *testing.T) { // Enqueue 4 messages for i := range 4 { - w.queue <- bus.OutboundMessage{Channel: "test", ChatID: "1", Content: fmt.Sprintf("msg%d", i)} + w.queue <- testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "1", Content: fmt.Sprintf("msg%d", i)}) } // Wait enough time for all messages to be sent (4 msgs at 2/s = ~2s, give extra margin) @@ -529,7 +543,7 @@ func TestRunWorker_MessageSplitting(t *testing.T) { go m.runWorker(ctx, "test", w) // Send a message that should be split - w.queue <- bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello world"} + w.queue <- testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello world"}) time.Sleep(100 * time.Millisecond) @@ -570,7 +584,7 @@ func TestSendWithRetry_ExponentialBackoff(t *testing.T) { } ctx := context.Background() - msg := bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "1", Content: "hello"}) start := time.Now() m.sendWithRetry(ctx, "test", w, msg) @@ -630,7 +644,7 @@ func TestPreSend_PlaceholderEditSuccess(t *testing.T) { // Register placeholder m.RecordPlaceholder("test", "123", "456") - msg := bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"}) _, edited := m.preSend(context.Background(), "test", msg, ch) if !edited { @@ -660,7 +674,7 @@ func TestPreSend_PlaceholderEditFails_FallsThrough(t *testing.T) { m.RecordPlaceholder("test", "123", "456") - msg := bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"}) _, edited := m.preSend(context.Background(), "test", msg, ch) if edited { @@ -719,7 +733,7 @@ func TestPreSend_TypingStopCalled(t *testing.T) { stopCalled = true }) - msg := bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"}) m.preSend(context.Background(), "test", msg, ch) if !stopCalled { @@ -736,7 +750,7 @@ func TestPreSend_NoRegisteredState(t *testing.T) { }, } - msg := bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"}) _, edited := m.preSend(context.Background(), "test", msg, ch) if edited { @@ -766,7 +780,7 @@ func TestPreSend_TypingAndPlaceholder(t *testing.T) { }) m.RecordPlaceholder("test", "123", "456") - msg := bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"}) _, edited := m.preSend(context.Background(), "test", msg, ch) if !stopCalled { @@ -830,7 +844,7 @@ func TestRecordTypingStop_ReplacesExistingStop(t *testing.T) { t.Fatalf("expected replacement typing stop to stay active until preSend, got %d calls", newStopCalls) } - msg := bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"}) m.preSend(context.Background(), "test", msg, &mockChannel{}) if newStopCalls != 1 { @@ -864,7 +878,7 @@ func TestSendWithRetry_PreSendEditsPlaceholder(t *testing.T) { limiter: rate.NewLimiter(rate.Inf, 1), } - msg := bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "123", Content: "hello"}) m.sendWithRetry(context.Background(), "test", w, msg) if sendCalled { @@ -1027,7 +1041,7 @@ func TestPreSendStillWorksWithWrappedTypes(t *testing.T) { }) m.RecordPlaceholder("test", "chat1", "ph_id") - msg := bus.OutboundMessage{Channel: "test", ChatID: "chat1", Content: "response"} + msg := testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "chat1", Content: "response"}) _, edited := m.preSend(context.Background(), "test", msg, ch) if !stopCalled { @@ -1130,11 +1144,11 @@ func TestManager_PlaceholderConsumedByResponse(t *testing.T) { // Transcription feedback arrives first — it should consume the placeholder // and be delivered via EditMessage, not Send. - msgTranscript := bus.OutboundMessage{ + msgTranscript := testOutboundMessage(bus.OutboundMessage{ Channel: "mock", ChatID: "chat-1", Content: "Transcript: hello", - } + }) mgr.sendWithRetry(ctx, "mock", worker, msgTranscript) if mockCh.editedMessages != 1 { @@ -1150,11 +1164,11 @@ func TestManager_PlaceholderConsumedByResponse(t *testing.T) { } // Final LLM response arrives — no placeholder left, so it goes through Send - msgFinal := bus.OutboundMessage{ + msgFinal := testOutboundMessage(bus.OutboundMessage{ Channel: "mock", ChatID: "chat-1", Content: "Final Answer", - } + }) mgr.sendWithRetry(ctx, "mock", worker, msgFinal) if len(mockCh.sentMessages) != 1 { @@ -1180,12 +1194,12 @@ func TestSendMessage_Synchronous(t *testing.T) { m.channels["test"] = ch m.workers["test"] = w - msg := bus.OutboundMessage{ + msg := testOutboundMessage(bus.OutboundMessage{ Channel: "test", ChatID: "123", Content: "hello world", ReplyToMessageID: "msg-456", - } + }) err := m.SendMessage(context.Background(), msg) if err != nil { @@ -1207,11 +1221,11 @@ func TestSendMessage_Synchronous(t *testing.T) { func TestSendMessage_UnknownChannel(t *testing.T) { m := newTestManager() - msg := bus.OutboundMessage{ + msg := testOutboundMessage(bus.OutboundMessage{ Channel: "nonexistent", ChatID: "123", Content: "hello", - } + }) err := m.SendMessage(context.Background(), msg) if err == nil { @@ -1228,11 +1242,11 @@ func TestSendMessage_NoWorker(t *testing.T) { m.channels["test"] = ch // No worker registered - msg := bus.OutboundMessage{ + msg := testOutboundMessage(bus.OutboundMessage{ Channel: "test", ChatID: "123", Content: "hello", - } + }) err := m.SendMessage(context.Background(), msg) if err == nil { @@ -1261,11 +1275,11 @@ func TestSendMessage_WithRetry(t *testing.T) { m.channels["test"] = ch m.workers["test"] = w - msg := bus.OutboundMessage{ + msg := testOutboundMessage(bus.OutboundMessage{ Channel: "test", ChatID: "123", Content: "retry me", - } + }) err := m.SendMessage(context.Background(), msg) if err != nil { @@ -1277,6 +1291,46 @@ func TestSendMessage_WithRetry(t *testing.T) { } } +func TestSendMessage_ContextOnlyUsesContextAddressing(t *testing.T) { + m := newTestManager() + + var received []bus.OutboundMessage + ch := &mockChannel{ + sendFn: func(_ context.Context, msg bus.OutboundMessage) error { + received = append(received, msg) + return nil + }, + } + + w := &channelWorker{ + ch: ch, + limiter: rate.NewLimiter(rate.Inf, 1), + } + m.channels["test"] = ch + m.workers["test"] = w + + msg := testOutboundMessage(bus.OutboundMessage{ + Context: bus.NewOutboundContext("test", "123", "msg-9"), + Content: "hello", + }) + + if err := m.SendMessage(context.Background(), msg); err != nil { + t.Fatalf("expected no error, got %v", err) + } + if len(received) != 1 { + t.Fatalf("expected 1 message sent, got %d", len(received)) + } + if received[0].Channel != "test" || received[0].ChatID != "123" { + t.Fatalf("expected mirrored legacy address, got %+v", received[0]) + } + if received[0].Context.Channel != "test" || received[0].Context.ChatID != "123" { + t.Fatalf("expected context address to be preserved, got %+v", received[0].Context) + } + if received[0].ReplyToMessageID != "msg-9" { + t.Fatalf("expected reply_to_message_id msg-9, got %q", received[0].ReplyToMessageID) + } +} + func TestSendMessage_WithSplitting(t *testing.T) { m := newTestManager() @@ -1298,11 +1352,11 @@ func TestSendMessage_WithSplitting(t *testing.T) { m.channels["test"] = ch m.workers["test"] = w - msg := bus.OutboundMessage{ + msg := testOutboundMessage(bus.OutboundMessage{ Channel: "test", ChatID: "123", Content: "hello world", - } + }) err := m.SendMessage(context.Background(), msg) if err != nil { @@ -1314,6 +1368,43 @@ func TestSendMessage_WithSplitting(t *testing.T) { } } +func TestSendMedia_ContextOnlyUsesContextAddressing(t *testing.T) { + m := newTestManager() + + var received []bus.OutboundMediaMessage + ch := &mockMediaChannel{ + sendMediaFn: func(_ context.Context, msg bus.OutboundMediaMessage) ([]string, error) { + received = append(received, msg) + return nil, nil + }, + } + + w := &channelWorker{ + ch: ch, + limiter: rate.NewLimiter(rate.Inf, 1), + } + m.channels["test"] = ch + m.workers["test"] = w + + msg := testOutboundMediaMessage(bus.OutboundMediaMessage{ + Context: bus.NewOutboundContext("test", "media-chat", ""), + Parts: []bus.MediaPart{{Type: "image", Ref: "media://1"}}, + }) + + if err := m.SendMedia(context.Background(), msg); err != nil { + t.Fatalf("expected no error, got %v", err) + } + if len(received) != 1 { + t.Fatalf("expected 1 media message sent, got %d", len(received)) + } + if received[0].Channel != "test" || received[0].ChatID != "media-chat" { + t.Fatalf("expected mirrored legacy media address, got %+v", received[0]) + } + if received[0].Context.Channel != "test" || received[0].Context.ChatID != "media-chat" { + t.Fatalf("expected media context address to be preserved, got %+v", received[0].Context) + } +} + func TestSendMessage_PreservesOrdering(t *testing.T) { m := newTestManager() @@ -1333,12 +1424,12 @@ func TestSendMessage_PreservesOrdering(t *testing.T) { m.workers["test"] = w // Send two messages sequentially — they must arrive in order - _ = m.SendMessage(context.Background(), bus.OutboundMessage{ + _ = m.SendMessage(context.Background(), testOutboundMessage(bus.OutboundMessage{ Channel: "test", ChatID: "1", Content: "first", - }) - _ = m.SendMessage(context.Background(), bus.OutboundMessage{ + })) + _ = m.SendMessage(context.Background(), testOutboundMessage(bus.OutboundMessage{ Channel: "test", ChatID: "1", Content: "second", - }) + })) if len(order) != 2 { t.Fatalf("expected 2 messages, got %d", len(order)) diff --git a/pkg/channels/matrix/matrix.go b/pkg/channels/matrix/matrix.go index 96db964cf..431fc5dc8 100644 --- a/pkg/channels/matrix/matrix.go +++ b/pkg/channels/matrix/matrix.go @@ -736,10 +736,8 @@ func (c *MatrixChannel) handleMessageEvent(ctx context.Context, evt *event.Event } peerKind := "direct" - peerID := senderID if isGroup { peerKind = "group" - peerID = roomID } metadata := map[string]string{ @@ -752,17 +750,19 @@ func (c *MatrixChannel) handleMessageEvent(ctx context.Context, evt *event.Event metadata["reply_to_msg_id"] = replyTo.String() } - c.HandleMessage( - c.baseContext(), - bus.Peer{Kind: peerKind, ID: peerID}, - evt.ID.String(), - senderID, - roomID, - content, - mediaPaths, - metadata, - sender, - ) + inboundCtx := bus.InboundContext{ + Channel: "matrix", + ChatID: roomID, + ChatType: peerKind, + SenderID: senderID, + MessageID: evt.ID.String(), + Raw: metadata, + } + if replyTo := msgEvt.GetRelatesTo().GetReplyTo(); replyTo != "" { + inboundCtx.ReplyToMessageID = replyTo.String() + } + + c.HandleInboundContext(c.baseContext(), roomID, content, mediaPaths, inboundCtx, sender) } // decryptEvent decrypts an encrypted event and returns the decrypted message event content. diff --git a/pkg/channels/onebot/onebot.go b/pkg/channels/onebot/onebot.go index e5651b046..4f8dff234 100644 --- a/pkg/channels/onebot/onebot.go +++ b/pkg/channels/onebot/onebot.go @@ -994,8 +994,6 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) { var contextChatID string var contextChatType string - var peer bus.Peer - metadata := map[string]string{} if parsed.ReplyTo != "" { @@ -1007,14 +1005,12 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) { chatID = "private:" + senderID contextChatID = senderID contextChatType = "direct" - peer = bus.Peer{Kind: "direct", ID: senderID} case "group": groupIDStr := strconv.FormatInt(groupID, 10) chatID = "group:" + groupIDStr contextChatID = groupIDStr contextChatType = "group" - peer = bus.Peer{Kind: "group", ID: groupIDStr} metadata["group_id"] = groupIDStr senderUserID, _ := parseJSONInt64(sender.UserID) @@ -1089,7 +1085,7 @@ func (c *OneBotChannel) handleMessage(raw *oneBotRawEvent) { Raw: metadata, } - c.HandleMessageWithContext(c.ctx, peer, chatID, content, parsed.Media, inboundCtx, senderInfo) + c.HandleInboundContext(c.ctx, chatID, content, parsed.Media, inboundCtx, senderInfo) } func (c *OneBotChannel) isDuplicate(messageID string) bool { diff --git a/pkg/channels/pico/client.go b/pkg/channels/pico/client.go index b4bfd09e5..91af34e4c 100644 --- a/pkg/channels/pico/client.go +++ b/pkg/channels/pico/client.go @@ -254,8 +254,6 @@ func (c *PicoClientChannel) handleServerMessage(pc *picoConn, msg PicoMessage) { chatID := "pico_client:" + sessionID senderID := "pico-remote" - peer := bus.Peer{Kind: "direct", ID: chatID} - sender := bus.SenderInfo{ Platform: "pico_client", PlatformID: senderID, @@ -266,10 +264,19 @@ func (c *PicoClientChannel) handleServerMessage(pc *picoConn, msg PicoMessage) { return } - c.HandleMessage(c.ctx, peer, msg.ID, senderID, chatID, content, nil, map[string]string{ - "platform": "pico_client", - "session_id": sessionID, - }, sender) + inboundCtx := bus.InboundContext{ + Channel: "pico_client", + ChatID: chatID, + ChatType: "direct", + SenderID: senderID, + MessageID: msg.ID, + Raw: map[string]string{ + "platform": "pico_client", + "session_id": sessionID, + }, + } + + c.HandleInboundContext(c.ctx, chatID, content, nil, inboundCtx, sender) } // Send sends a message to the remote server. diff --git a/pkg/channels/pico/pico.go b/pkg/channels/pico/pico.go index 0a7bf15a4..4f3f4aba3 100644 --- a/pkg/channels/pico/pico.go +++ b/pkg/channels/pico/pico.go @@ -539,8 +539,6 @@ func (c *PicoChannel) handleMessageSend(pc *picoConn, msg PicoMessage) { chatID := "pico:" + sessionID senderID := "pico-user" - peer := bus.Peer{Kind: "direct", ID: "pico:" + sessionID} - metadata := map[string]string{ "platform": "pico", "session_id": sessionID, @@ -562,7 +560,16 @@ func (c *PicoChannel) handleMessageSend(pc *picoConn, msg PicoMessage) { return } - c.HandleMessage(c.ctx, peer, msg.ID, senderID, chatID, content, nil, metadata, sender) + inboundCtx := bus.InboundContext{ + Channel: "pico", + ChatID: chatID, + ChatType: "direct", + SenderID: senderID, + MessageID: msg.ID, + Raw: metadata, + } + + c.HandleInboundContext(c.ctx, chatID, content, nil, inboundCtx, sender) } // truncate truncates a string to maxLen runes. diff --git a/pkg/channels/qq/qq.go b/pkg/channels/qq/qq.go index ba0045da6..aa78d8e85 100644 --- a/pkg/channels/qq/qq.go +++ b/pkg/channels/qq/qq.go @@ -657,15 +657,7 @@ func (c *QQChannel) handleC2CMessage() event.C2CMessageEventHandler { Raw: metadata, } - c.HandleMessageWithContext( - c.ctx, - bus.Peer{Kind: "direct", ID: senderID}, - senderID, - content, - mediaPaths, - inboundCtx, - sender, - ) + c.HandleInboundContext(c.ctx, senderID, content, mediaPaths, inboundCtx, sender) return nil } @@ -744,15 +736,7 @@ func (c *QQChannel) handleGroupATMessage() event.GroupATMessageEventHandler { Raw: metadata, } - c.HandleMessageWithContext( - c.ctx, - bus.Peer{Kind: "group", ID: data.GroupID}, - data.GroupID, - content, - mediaPaths, - inboundCtx, - sender, - ) + c.HandleInboundContext(c.ctx, data.GroupID, content, mediaPaths, inboundCtx, sender) return nil } diff --git a/pkg/channels/slack/slack.go b/pkg/channels/slack/slack.go index 882cc5cb5..543f6f338 100644 --- a/pkg/channels/slack/slack.go +++ b/pkg/channels/slack/slack.go @@ -356,14 +356,10 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) { } peerKind := "channel" - peerID := channelID if strings.HasPrefix(channelID, "D") { peerKind = "direct" - peerID = senderID } - peer := bus.Peer{Kind: peerKind, ID: peerID} - metadata := map[string]string{ "message_ts": messageTS, "channel_id": channelID, @@ -394,7 +390,7 @@ func (c *SlackChannel) handleMessageEvent(ev *slackevents.MessageEvent) { inboundCtx.TopicID = threadTS } - c.HandleMessageWithContext(c.ctx, peer, chatID, content, mediaPaths, inboundCtx, sender) + c.HandleInboundContext(c.ctx, chatID, content, mediaPaths, inboundCtx, sender) } func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) { @@ -442,14 +438,10 @@ func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) { } mentionPeerKind := "channel" - mentionPeerID := channelID if strings.HasPrefix(channelID, "D") { mentionPeerKind = "direct" - mentionPeerID = senderID } - mentionPeer := bus.Peer{Kind: mentionPeerKind, ID: mentionPeerID} - metadata := map[string]string{ "message_ts": messageTS, "channel_id": channelID, @@ -472,7 +464,7 @@ func (c *SlackChannel) handleAppMention(ev *slackevents.AppMentionEvent) { Raw: metadata, } - c.HandleMessageWithContext(c.ctx, mentionPeer, chatID, content, nil, inboundCtx, mentionSender) + c.HandleInboundContext(c.ctx, chatID, content, nil, inboundCtx, mentionSender) } func (c *SlackChannel) handleSlashCommand(event socketmode.Event) { @@ -520,10 +512,8 @@ func (c *SlackChannel) handleSlashCommand(event socketmode.Event) { "text": utils.Truncate(content, 50), }) peerKind := "channel" - peerID := channelID if strings.HasPrefix(channelID, "D") { peerKind = "direct" - peerID = senderID } inboundCtx := bus.InboundContext{ Channel: c.Name(), @@ -536,15 +526,7 @@ func (c *SlackChannel) handleSlashCommand(event socketmode.Event) { Raw: metadata, } - c.HandleMessageWithContext( - c.ctx, - bus.Peer{Kind: peerKind, ID: peerID}, - chatID, - content, - nil, - inboundCtx, - cmdSender, - ) + c.HandleInboundContext(c.ctx, chatID, content, nil, inboundCtx, cmdSender) } func (c *SlackChannel) downloadSlackFile(file slack.File) string { diff --git a/pkg/channels/telegram/telegram.go b/pkg/channels/telegram/telegram.go index e1532bcf9..31a5afb30 100644 --- a/pkg/channels/telegram/telegram.go +++ b/pkg/channels/telegram/telegram.go @@ -708,13 +708,9 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes }) peerKind := "direct" - peerID := fmt.Sprintf("%d", user.ID) if message.Chat.Type != "private" { peerKind = "group" - peerID = compositeChatID } - - peer := bus.Peer{Kind: peerKind, ID: peerID} messageID := fmt.Sprintf("%d", message.MessageID) metadata := map[string]string{ @@ -742,7 +738,6 @@ func (c *TelegramChannel) handleMessage(ctx context.Context, message *telego.Mes c.HandleMessageWithContext( c.ctx, - peer, compositeChatID, content, mediaPaths, diff --git a/pkg/channels/wecom/wecom.go b/pkg/channels/wecom/wecom.go index 65b9b4ca4..10b95a20f 100644 --- a/pkg/channels/wecom/wecom.go +++ b/pkg/channels/wecom/wecom.go @@ -570,7 +570,6 @@ func (c *WeComChannel) dispatchIncoming(reqID string, msg wecomIncomingMessage) return err } - peer := bus.Peer{Kind: peerKind, ID: actualChatID} metadata := map[string]string{ "channel": "wecom", "req_id": reqID, @@ -596,7 +595,7 @@ func (c *WeComChannel) dispatchIncoming(reqID string, msg wecomIncomingMessage) Raw: metadata, } - c.HandleMessageWithContext(c.ctx, peer, actualChatID, content, mediaRefs, inboundCtx, sender) + c.HandleInboundContext(c.ctx, actualChatID, content, mediaRefs, inboundCtx, sender) return nil } diff --git a/pkg/channels/weixin/weixin.go b/pkg/channels/weixin/weixin.go index 0e9010131..5e62a8a3b 100644 --- a/pkg/channels/weixin/weixin.go +++ b/pkg/channels/weixin/weixin.go @@ -334,8 +334,6 @@ func (c *WeixinChannel) handleInboundMessage(ctx context.Context, msg WeixinMess return } - peer := bus.Peer{Kind: "direct", ID: fromUserID} - metadata := map[string]string{ "from_user_id": fromUserID, "context_token": msg.ContextToken, @@ -354,7 +352,21 @@ func (c *WeixinChannel) handleInboundMessage(ctx context.Context, msg WeixinMess c.persistContextTokens() } - c.HandleMessage(ctx, peer, messageID, fromUserID, fromUserID, content, mediaRefs, metadata, sender) + inboundCtx := bus.InboundContext{ + Channel: "weixin", + ChatID: fromUserID, + ChatType: "direct", + SenderID: fromUserID, + MessageID: messageID, + Raw: metadata, + } + if msg.ContextToken != "" { + inboundCtx.ReplyHandles = map[string]string{ + "context_token": msg.ContextToken, + } + } + + c.HandleInboundContext(ctx, fromUserID, content, mediaRefs, inboundCtx, sender) } // Send implements channels.Channel by sending a text message to the WeChat user. diff --git a/pkg/channels/whatsapp/whatsapp.go b/pkg/channels/whatsapp/whatsapp.go index 98622fe37..7064da219 100644 --- a/pkg/channels/whatsapp/whatsapp.go +++ b/pkg/channels/whatsapp/whatsapp.go @@ -223,13 +223,6 @@ func (c *WhatsAppChannel) handleIncomingMessage(msg map[string]any) { metadata["user_name"] = userName } - var peer bus.Peer - if chatID == senderID { - peer = bus.Peer{Kind: "direct", ID: senderID} - } else { - peer = bus.Peer{Kind: "group", ID: chatID} - } - logger.InfoCF("whatsapp", "WhatsApp message received", map[string]any{ "sender": senderID, "preview": utils.Truncate(content, 50), @@ -248,5 +241,18 @@ func (c *WhatsAppChannel) handleIncomingMessage(msg map[string]any) { return } - c.HandleMessage(c.ctx, peer, messageID, senderID, chatID, content, mediaPaths, metadata, sender) + inboundCtx := bus.InboundContext{ + Channel: "whatsapp", + ChatID: chatID, + SenderID: senderID, + MessageID: messageID, + Raw: metadata, + } + if chatID == senderID { + inboundCtx.ChatType = "direct" + } else { + inboundCtx.ChatType = "group" + } + + c.HandleInboundContext(c.ctx, chatID, content, mediaPaths, inboundCtx, sender) } diff --git a/pkg/channels/whatsapp_native/whatsapp_native.go b/pkg/channels/whatsapp_native/whatsapp_native.go index d0a74a405..a1e6e50cd 100644 --- a/pkg/channels/whatsapp_native/whatsapp_native.go +++ b/pkg/channels/whatsapp_native/whatsapp_native.go @@ -375,7 +375,6 @@ func (c *WhatsAppNativeChannel) handleIncoming(evt *events.Message) { if evt.Info.Chat.Server == types.GroupServer { peerKind = "group" } - peer := bus.Peer{Kind: peerKind, ID: chatID} messageID := evt.Info.ID sender := bus.SenderInfo{ Platform: "whatsapp", @@ -393,7 +392,17 @@ func (c *WhatsAppNativeChannel) handleIncoming(evt *events.Message) { "WhatsApp message received", map[string]any{"sender_id": senderID, "content_preview": utils.Truncate(content, 50)}, ) - c.HandleMessage(c.runCtx, peer, messageID, senderID, chatID, content, mediaPaths, metadata, sender) + + inboundCtx := bus.InboundContext{ + Channel: "whatsapp", + ChatID: chatID, + SenderID: senderID, + MessageID: messageID, + ChatType: peerKind, + Raw: metadata, + } + + c.HandleInboundContext(c.runCtx, chatID, content, mediaPaths, inboundCtx, sender) } func (c *WhatsAppNativeChannel) Send(ctx context.Context, msg bus.OutboundMessage) ([]string, error) { diff --git a/pkg/config/config.go b/pkg/config/config.go index 10eb07339..014c90045 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -99,7 +99,7 @@ type BuildInfo struct { } // MarshalJSON implements custom JSON marshaling for Config -// to omit providers section when empty and session when empty +// to omit providers section when empty and session when empty. func (c *Config) MarshalJSON() ([]byte, error) { type Alias Config aux := &struct { @@ -109,11 +109,8 @@ func (c *Config) MarshalJSON() ([]byte, error) { Alias: (*Alias)(c), } - // Only include session if not empty. Deprecated dm_scope is intentionally - // omitted so persisted configs converge on dimensions-based session policy. if len(c.Session.Dimensions) > 0 || len(c.Session.IdentityLinks) > 0 { sessionCfg := c.Session - sessionCfg.DMScope = "" aux.Session = &sessionCfg } @@ -199,7 +196,6 @@ type AgentBinding struct { type SessionConfig struct { Dimensions []string `json:"dimensions,omitempty"` - DMScope string `json:"dm_scope,omitempty"` // Deprecated: ignored by the new session policy path. IdentityLinks map[string][]string `json:"identity_links,omitempty"` } diff --git a/pkg/devices/service.go b/pkg/devices/service.go index 1bafe6085..1cf2a686e 100644 --- a/pkg/devices/service.go +++ b/pkg/devices/service.go @@ -131,8 +131,7 @@ func (s *Service) sendNotification(ev *events.DeviceEvent) { pubCtx, pubCancel := context.WithTimeout(context.Background(), 5*time.Second) defer pubCancel() msgBus.PublishOutbound(pubCtx, bus.OutboundMessage{ - Channel: platform, - ChatID: userID, + Context: bus.NewOutboundContext(platform, userID, ""), Content: msg, }) diff --git a/pkg/heartbeat/service.go b/pkg/heartbeat/service.go index 5dda78ea9..e5b28ec11 100644 --- a/pkg/heartbeat/service.go +++ b/pkg/heartbeat/service.go @@ -339,8 +339,7 @@ func (hs *HeartbeatService) sendResponse(response string) { pubCtx, pubCancel := context.WithTimeout(context.Background(), 5*time.Second) defer pubCancel() msgBus.PublishOutbound(pubCtx, bus.OutboundMessage{ - Channel: platform, - ChatID: userID, + Context: bus.NewOutboundContext(platform, userID, ""), Content: response, }) diff --git a/pkg/routing/route.go b/pkg/routing/route.go index e5a000067..88a0006da 100644 --- a/pkg/routing/route.go +++ b/pkg/routing/route.go @@ -3,25 +3,21 @@ package routing import ( "strings" + "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/config" ) -// RouteInput contains the routing context from an inbound message. -type RouteInput struct { - Channel string - AccountID string - Peer *RoutePeer - ParentPeer *RoutePeer - GuildID string - TeamID string -} - // SessionPolicy describes how a routed message should be mapped to a session. type SessionPolicy struct { Dimensions []string IdentityLinks map[string][]string } +type RoutePeer struct { + Kind string + ID string +} + // ResolvedRoute is the result of agent routing. type ResolvedRoute struct { AgentID string @@ -41,14 +37,15 @@ func NewRouteResolver(cfg *config.Config) *RouteResolver { return &RouteResolver{cfg: cfg} } -// ResolveRoute determines which agent handles the message and returns the -// session policy that should be used to allocate session state. +// ResolveRoute determines which agent handles the message from a normalized +// inbound context and returns the session policy that should be used to +// allocate session state. // Implements the 7-level priority cascade: // peer > parent_peer > guild > team > account > channel_wildcard > default -func (r *RouteResolver) ResolveRoute(input RouteInput) ResolvedRoute { - channel := strings.ToLower(strings.TrimSpace(input.Channel)) - accountID := NormalizeAccountID(input.AccountID) - peer := input.Peer +func (r *RouteResolver) ResolveRoute(inbound bus.InboundContext) ResolvedRoute { + channel := strings.ToLower(strings.TrimSpace(inbound.Channel)) + accountID := NormalizeAccountID(inbound.Account) + peer := routePeerFromContext(inbound) sessionPolicy := r.sessionPolicy() @@ -73,7 +70,7 @@ func (r *RouteResolver) ResolveRoute(input RouteInput) ResolvedRoute { } // Priority 2: Parent peer binding - parentPeer := input.ParentPeer + parentPeer := parentPeerFromContext(inbound) if parentPeer != nil && strings.TrimSpace(parentPeer.ID) != "" { if match := r.findPeerMatch(bindings, parentPeer); match != nil { return choose(match.AgentID, "binding.peer.parent") @@ -81,7 +78,7 @@ func (r *RouteResolver) ResolveRoute(input RouteInput) ResolvedRoute { } // Priority 3: Guild binding - guildID := strings.TrimSpace(input.GuildID) + guildID := routeGuildIDFromContext(inbound) if guildID != "" { if match := r.findGuildMatch(bindings, guildID); match != nil { return choose(match.AgentID, "binding.guild") @@ -89,7 +86,7 @@ func (r *RouteResolver) ResolveRoute(input RouteInput) ResolvedRoute { } // Priority 4: Team binding - teamID := strings.TrimSpace(input.TeamID) + teamID := routeTeamIDFromContext(inbound) if teamID != "" { if match := r.findTeamMatch(bindings, teamID); match != nil { return choose(match.AgentID, "binding.team") @@ -276,6 +273,46 @@ func normalizeSessionDimensions(dimensions []string) []string { return normalized } +func routePeerFromContext(ctx bus.InboundContext) *RoutePeer { + peerKind := normalizeChannel(strings.TrimSpace(ctx.ChatType)) + if peerKind == "" || peerKind == "unknown" { + return nil + } + + peerID := strings.TrimSpace(ctx.ChatID) + if peerKind == "direct" && peerID == "" { + peerID = strings.TrimSpace(ctx.SenderID) + } + if peerID == "" { + return nil + } + + return &RoutePeer{Kind: peerKind, ID: peerID} +} + +func parentPeerFromContext(ctx bus.InboundContext) *RoutePeer { + if topicID := strings.TrimSpace(ctx.TopicID); topicID != "" { + return &RoutePeer{Kind: "topic", ID: topicID} + } + return nil +} + +func routeGuildIDFromContext(ctx bus.InboundContext) string { + if strings.EqualFold(strings.TrimSpace(ctx.SpaceType), "guild") { + return strings.TrimSpace(ctx.SpaceID) + } + return "" +} + +func routeTeamIDFromContext(ctx bus.InboundContext) string { + switch strings.ToLower(strings.TrimSpace(ctx.SpaceType)) { + case "team", "workspace": + return strings.TrimSpace(ctx.SpaceID) + default: + return "" + } +} + func cloneIdentityLinks(src map[string][]string) map[string][]string { if len(src) == 0 { return nil @@ -288,3 +325,7 @@ func cloneIdentityLinks(src map[string][]string) map[string][]string { } return cloned } + +func normalizeChannel(value string) string { + return strings.ToLower(strings.TrimSpace(value)) +} diff --git a/pkg/routing/route_test.go b/pkg/routing/route_test.go index 3397bd8e8..46a0f9f13 100644 --- a/pkg/routing/route_test.go +++ b/pkg/routing/route_test.go @@ -3,6 +3,7 @@ package routing import ( "testing" + "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/config" ) @@ -26,9 +27,10 @@ func TestResolveRoute_DefaultAgent_NoBindings(t *testing.T) { cfg := testConfig(nil, nil) r := NewRouteResolver(cfg) - route := r.ResolveRoute(RouteInput{ - Channel: "telegram", - Peer: &RoutePeer{Kind: "direct", ID: "user1"}, + route := r.ResolveRoute(bus.InboundContext{ + Channel: "telegram", + ChatType: "direct", + SenderID: "user1", }) if route.AgentID != DefaultAgentID { @@ -63,9 +65,10 @@ func TestResolveRoute_PeerBinding(t *testing.T) { cfg := testConfig(agents, bindings) r := NewRouteResolver(cfg) - route := r.ResolveRoute(RouteInput{ - Channel: "telegram", - Peer: &RoutePeer{Kind: "direct", ID: "user123"}, + route := r.ResolveRoute(bus.InboundContext{ + Channel: "telegram", + ChatType: "direct", + SenderID: "user123", }) if route.AgentID != "support" { @@ -94,10 +97,12 @@ func TestResolveRoute_GuildBinding(t *testing.T) { cfg := testConfig(agents, bindings) r := NewRouteResolver(cfg) - route := r.ResolveRoute(RouteInput{ - Channel: "discord", - GuildID: "guild-abc", - Peer: &RoutePeer{Kind: "channel", ID: "ch1"}, + route := r.ResolveRoute(bus.InboundContext{ + Channel: "discord", + ChatID: "ch1", + ChatType: "channel", + SpaceID: "guild-abc", + SpaceType: "guild", }) if route.AgentID != "gaming" { @@ -126,10 +131,12 @@ func TestResolveRoute_TeamBinding(t *testing.T) { cfg := testConfig(agents, bindings) r := NewRouteResolver(cfg) - route := r.ResolveRoute(RouteInput{ - Channel: "slack", - TeamID: "T12345", - Peer: &RoutePeer{Kind: "channel", ID: "C001"}, + route := r.ResolveRoute(bus.InboundContext{ + Channel: "slack", + ChatID: "C001", + ChatType: "channel", + SpaceID: "T12345", + SpaceType: "team", }) if route.AgentID != "work" { @@ -157,10 +164,11 @@ func TestResolveRoute_AccountBinding(t *testing.T) { cfg := testConfig(agents, bindings) r := NewRouteResolver(cfg) - route := r.ResolveRoute(RouteInput{ - Channel: "telegram", - AccountID: "bot2", - Peer: &RoutePeer{Kind: "direct", ID: "user1"}, + route := r.ResolveRoute(bus.InboundContext{ + Channel: "telegram", + Account: "bot2", + ChatType: "direct", + SenderID: "user1", }) if route.AgentID != "premium" { @@ -188,9 +196,10 @@ func TestResolveRoute_ChannelWildcard(t *testing.T) { cfg := testConfig(agents, bindings) r := NewRouteResolver(cfg) - route := r.ResolveRoute(RouteInput{ - Channel: "telegram", - Peer: &RoutePeer{Kind: "direct", ID: "user1"}, + route := r.ResolveRoute(bus.InboundContext{ + Channel: "telegram", + ChatType: "direct", + SenderID: "user1", }) if route.AgentID != "telegram-bot" { @@ -228,10 +237,12 @@ func TestResolveRoute_PriorityOrder_PeerBeatsGuild(t *testing.T) { cfg := testConfig(agents, bindings) r := NewRouteResolver(cfg) - route := r.ResolveRoute(RouteInput{ - Channel: "discord", - GuildID: "guild-1", - Peer: &RoutePeer{Kind: "direct", ID: "user-vip"}, + route := r.ResolveRoute(bus.InboundContext{ + Channel: "discord", + ChatType: "direct", + SenderID: "user-vip", + SpaceID: "guild-1", + SpaceType: "guild", }) if route.AgentID != "vip" { @@ -258,9 +269,7 @@ func TestResolveRoute_InvalidAgentFallsToDefault(t *testing.T) { cfg := testConfig(agents, bindings) r := NewRouteResolver(cfg) - route := r.ResolveRoute(RouteInput{ - Channel: "telegram", - }) + route := r.ResolveRoute(bus.InboundContext{Channel: "telegram"}) if route.AgentID != "main" { t.Errorf("AgentID = %q, want 'main' (invalid agent should fall to default)", route.AgentID) @@ -276,9 +285,7 @@ func TestResolveRoute_DefaultAgentSelection(t *testing.T) { cfg := testConfig(agents, nil) r := NewRouteResolver(cfg) - route := r.ResolveRoute(RouteInput{ - Channel: "cli", - }) + route := r.ResolveRoute(bus.InboundContext{Channel: "cli"}) if route.AgentID != "beta" { t.Errorf("AgentID = %q, want 'beta' (marked as default)", route.AgentID) @@ -293,9 +300,7 @@ func TestResolveRoute_NoDefaultUsesFirst(t *testing.T) { cfg := testConfig(agents, nil) r := NewRouteResolver(cfg) - route := r.ResolveRoute(RouteInput{ - Channel: "cli", - }) + route := r.ResolveRoute(bus.InboundContext{Channel: "cli"}) if route.AgentID != "alpha" { t.Errorf("AgentID = %q, want 'alpha' (first in list)", route.AgentID) diff --git a/pkg/routing/session_key.go b/pkg/routing/session_key.go deleted file mode 100644 index cc3ce43f3..000000000 --- a/pkg/routing/session_key.go +++ /dev/null @@ -1,218 +0,0 @@ -package routing - -import ( - "fmt" - "strings" -) - -// DMScope controls DM session isolation granularity. -type DMScope string - -const ( - DMScopeMain DMScope = "main" - DMScopePerPeer DMScope = "per-peer" - DMScopePerChannelPeer DMScope = "per-channel-peer" - DMScopePerAccountChannelPeer DMScope = "per-account-channel-peer" -) - -// RoutePeer represents a chat peer with kind and ID. -type RoutePeer struct { - Kind string // "direct", "group", "channel" - ID string -} - -// SessionKeyParams holds all inputs for session key construction. -type SessionKeyParams struct { - AgentID string - Channel string - AccountID string - Peer *RoutePeer - DMScope DMScope - IdentityLinks map[string][]string -} - -// ParsedSessionKey is the result of parsing an agent-scoped session key. -type ParsedSessionKey struct { - AgentID string - Rest string -} - -// BuildAgentMainSessionKey returns "agent::main". -func BuildAgentMainSessionKey(agentID string) string { - return fmt.Sprintf("agent:%s:%s", NormalizeAgentID(agentID), DefaultMainKey) -} - -// BuildAgentPeerSessionKey constructs a session key based on agent, channel, peer, and DM scope. -func BuildAgentPeerSessionKey(params SessionKeyParams) string { - agentID := NormalizeAgentID(params.AgentID) - - peer := params.Peer - if peer == nil { - peer = &RoutePeer{Kind: "direct"} - } - peerKind := strings.TrimSpace(peer.Kind) - if peerKind == "" { - peerKind = "direct" - } - - if peerKind == "direct" { - dmScope := params.DMScope - if dmScope == "" { - dmScope = DMScopeMain - } - peerID := CanonicalSessionPeerID(params.Channel, peer.ID, dmScope, params.IdentityLinks) - - switch dmScope { - case DMScopePerAccountChannelPeer: - if peerID != "" { - channel := normalizeChannel(params.Channel) - accountID := NormalizeAccountID(params.AccountID) - return fmt.Sprintf("agent:%s:%s:%s:direct:%s", agentID, channel, accountID, peerID) - } - case DMScopePerChannelPeer: - if peerID != "" { - channel := normalizeChannel(params.Channel) - return fmt.Sprintf("agent:%s:%s:direct:%s", agentID, channel, peerID) - } - case DMScopePerPeer: - if peerID != "" { - return fmt.Sprintf("agent:%s:direct:%s", agentID, peerID) - } - } - return BuildAgentMainSessionKey(agentID) - } - - // Group/channel peers always get per-peer sessions - channel := normalizeChannel(params.Channel) - peerID := strings.ToLower(strings.TrimSpace(peer.ID)) - if peerID == "" { - peerID = "unknown" - } - return fmt.Sprintf("agent:%s:%s:%s:%s", agentID, channel, peerKind, peerID) -} - -// CanonicalSessionPeerID applies the current DM session canonicalization rules, -// including identity-link collapse when enabled. -func CanonicalSessionPeerID( - channel, peerID string, - dmScope DMScope, - identityLinks map[string][]string, -) string { - normalizedPeerID := strings.TrimSpace(peerID) - if normalizedPeerID == "" { - return "" - } - - if dmScope != DMScopeMain { - if linked := resolveLinkedPeerID(identityLinks, channel, normalizedPeerID); linked != "" { - normalizedPeerID = linked - } - } - - return strings.ToLower(normalizedPeerID) -} - -// CanonicalSessionIdentityID collapses an identity using identity_links when -// possible, then returns a normalized lowercase identifier. -func CanonicalSessionIdentityID(channel, rawID string, identityLinks map[string][]string) string { - normalizedID := strings.TrimSpace(rawID) - if normalizedID == "" { - return "" - } - if linked := resolveLinkedPeerID(identityLinks, channel, normalizedID); linked != "" { - normalizedID = linked - } - return strings.ToLower(normalizedID) -} - -// ParseAgentSessionKey extracts agentId and rest from "agent::". -func ParseAgentSessionKey(sessionKey string) *ParsedSessionKey { - raw := strings.TrimSpace(sessionKey) - if raw == "" { - return nil - } - parts := strings.SplitN(raw, ":", 3) - if len(parts) < 3 { - return nil - } - if parts[0] != "agent" { - return nil - } - agentID := strings.TrimSpace(parts[1]) - rest := parts[2] - if agentID == "" || rest == "" { - return nil - } - return &ParsedSessionKey{AgentID: agentID, Rest: rest} -} - -// IsSubagentSessionKey returns true if the session key represents a subagent. -func IsSubagentSessionKey(sessionKey string) bool { - raw := strings.TrimSpace(sessionKey) - if raw == "" { - return false - } - if strings.HasPrefix(strings.ToLower(raw), "subagent:") { - return true - } - parsed := ParseAgentSessionKey(raw) - if parsed == nil { - return false - } - return strings.HasPrefix(strings.ToLower(parsed.Rest), "subagent:") -} - -func normalizeChannel(channel string) string { - c := strings.TrimSpace(strings.ToLower(channel)) - if c == "" { - return "unknown" - } - return c -} - -func resolveLinkedPeerID(identityLinks map[string][]string, channel, peerID string) string { - if len(identityLinks) == 0 { - return "" - } - peerID = strings.TrimSpace(peerID) - if peerID == "" { - return "" - } - - candidates := make(map[string]bool) - rawCandidate := strings.ToLower(peerID) - if rawCandidate != "" { - candidates[rawCandidate] = true - } - channel = strings.ToLower(strings.TrimSpace(channel)) - if channel != "" { - scopedCandidate := fmt.Sprintf("%s:%s", channel, strings.ToLower(peerID)) - candidates[scopedCandidate] = true - } - - // If peerID is already in canonical "platform:id" format, also add the - // bare ID part as a candidate for backward compatibility with identity_links - // that use raw IDs (e.g. "123" instead of "telegram:123"). - if idx := strings.Index(rawCandidate, ":"); idx > 0 && idx < len(rawCandidate)-1 { - bareID := rawCandidate[idx+1:] - candidates[bareID] = true - } - - if len(candidates) == 0 { - return "" - } - - for canonical, ids := range identityLinks { - canonicalName := strings.TrimSpace(canonical) - if canonicalName == "" { - continue - } - for _, id := range ids { - normalized := strings.ToLower(strings.TrimSpace(id)) - if normalized != "" && candidates[normalized] { - return canonicalName - } - } - } - return "" -} diff --git a/pkg/routing/session_key_test.go b/pkg/routing/session_key_test.go deleted file mode 100644 index ad7a1ca02..000000000 --- a/pkg/routing/session_key_test.go +++ /dev/null @@ -1,207 +0,0 @@ -package routing - -import "testing" - -func TestBuildAgentMainSessionKey(t *testing.T) { - got := BuildAgentMainSessionKey("sales") - want := "agent:sales:main" - if got != want { - t.Errorf("BuildAgentMainSessionKey('sales') = %q, want %q", got, want) - } -} - -func TestBuildAgentMainSessionKey_Normalizes(t *testing.T) { - got := BuildAgentMainSessionKey("Sales Bot") - want := "agent:sales-bot:main" - if got != want { - t.Errorf("BuildAgentMainSessionKey('Sales Bot') = %q, want %q", got, want) - } -} - -func TestBuildAgentPeerSessionKey_DMScopeMain(t *testing.T) { - got := BuildAgentPeerSessionKey(SessionKeyParams{ - AgentID: "main", - Channel: "telegram", - Peer: &RoutePeer{Kind: "direct", ID: "user123"}, - DMScope: DMScopeMain, - }) - want := "agent:main:main" - if got != want { - t.Errorf("DMScopeMain = %q, want %q", got, want) - } -} - -func TestBuildAgentPeerSessionKey_DMScopePerPeer(t *testing.T) { - got := BuildAgentPeerSessionKey(SessionKeyParams{ - AgentID: "main", - Channel: "telegram", - Peer: &RoutePeer{Kind: "direct", ID: "user123"}, - DMScope: DMScopePerPeer, - }) - want := "agent:main:direct:user123" - if got != want { - t.Errorf("DMScopePerPeer = %q, want %q", got, want) - } -} - -func TestBuildAgentPeerSessionKey_DMScopePerChannelPeer(t *testing.T) { - got := BuildAgentPeerSessionKey(SessionKeyParams{ - AgentID: "main", - Channel: "telegram", - Peer: &RoutePeer{Kind: "direct", ID: "user123"}, - DMScope: DMScopePerChannelPeer, - }) - want := "agent:main:telegram:direct:user123" - if got != want { - t.Errorf("DMScopePerChannelPeer = %q, want %q", got, want) - } -} - -func TestBuildAgentPeerSessionKey_DMScopePerAccountChannelPeer(t *testing.T) { - got := BuildAgentPeerSessionKey(SessionKeyParams{ - AgentID: "main", - Channel: "telegram", - AccountID: "bot1", - Peer: &RoutePeer{Kind: "direct", ID: "User123"}, - DMScope: DMScopePerAccountChannelPeer, - }) - want := "agent:main:telegram:bot1:direct:user123" - if got != want { - t.Errorf("DMScopePerAccountChannelPeer = %q, want %q", got, want) - } -} - -func TestBuildAgentPeerSessionKey_GroupPeer(t *testing.T) { - got := BuildAgentPeerSessionKey(SessionKeyParams{ - AgentID: "main", - Channel: "telegram", - Peer: &RoutePeer{Kind: "group", ID: "chat456"}, - DMScope: DMScopePerPeer, - }) - want := "agent:main:telegram:group:chat456" - if got != want { - t.Errorf("GroupPeer = %q, want %q", got, want) - } -} - -func TestBuildAgentPeerSessionKey_NilPeer(t *testing.T) { - got := BuildAgentPeerSessionKey(SessionKeyParams{ - AgentID: "main", - Channel: "telegram", - Peer: nil, - DMScope: DMScopePerPeer, - }) - // nil peer defaults to direct with empty ID, falls to main - want := "agent:main:main" - if got != want { - t.Errorf("NilPeer = %q, want %q", got, want) - } -} - -func TestBuildAgentPeerSessionKey_IdentityLink(t *testing.T) { - links := map[string][]string{ - "john": {"telegram:user123", "discord:john#1234"}, - } - got := BuildAgentPeerSessionKey(SessionKeyParams{ - AgentID: "main", - Channel: "telegram", - Peer: &RoutePeer{Kind: "direct", ID: "user123"}, - DMScope: DMScopePerPeer, - IdentityLinks: links, - }) - want := "agent:main:direct:john" - if got != want { - t.Errorf("IdentityLink = %q, want %q", got, want) - } -} - -func TestResolveLinkedPeerID_CanonicalPeerID(t *testing.T) { - // When peerID is already in canonical "platform:id" format, - // it should match identity_links that use the bare ID. - links := map[string][]string{ - "john": {"123"}, - } - got := resolveLinkedPeerID(links, "telegram", "telegram:123") - if got != "john" { - t.Errorf("resolveLinkedPeerID with canonical peerID = %q, want %q", got, "john") - } -} - -func TestResolveLinkedPeerID_CanonicalInLinks(t *testing.T) { - // When identity_links contain canonical IDs and peerID is canonical too - links := map[string][]string{ - "john": {"telegram:123", "discord:456"}, - } - got := resolveLinkedPeerID(links, "telegram", "telegram:123") - if got != "john" { - t.Errorf("resolveLinkedPeerID canonical in links = %q, want %q", got, "john") - } -} - -func TestResolveLinkedPeerID_BarePeerIDMatchesCanonicalLink(t *testing.T) { - // When peerID is bare "123" and links have "telegram:123", - // the scoped candidate "telegram:123" should match. - links := map[string][]string{ - "john": {"telegram:123"}, - } - got := resolveLinkedPeerID(links, "telegram", "123") - if got != "john" { - t.Errorf("resolveLinkedPeerID bare peer matches canonical link = %q, want %q", got, "john") - } -} - -func TestResolveLinkedPeerID_NoMatch(t *testing.T) { - links := map[string][]string{ - "john": {"telegram:123"}, - } - got := resolveLinkedPeerID(links, "discord", "999") - if got != "" { - t.Errorf("resolveLinkedPeerID no match = %q, want empty", got) - } -} - -func TestParseAgentSessionKey_Valid(t *testing.T) { - parsed := ParseAgentSessionKey("agent:sales:telegram:direct:user123") - if parsed == nil { - t.Fatal("expected non-nil result") - } - if parsed.AgentID != "sales" { - t.Errorf("AgentID = %q, want 'sales'", parsed.AgentID) - } - if parsed.Rest != "telegram:direct:user123" { - t.Errorf("Rest = %q, want 'telegram:direct:user123'", parsed.Rest) - } -} - -func TestParseAgentSessionKey_Invalid(t *testing.T) { - tests := []string{ - "", - "foo:bar", - "notprefix:sales:main", - "agent::main", - "agent:sales:", - } - for _, input := range tests { - if got := ParseAgentSessionKey(input); got != nil { - t.Errorf("ParseAgentSessionKey(%q) = %+v, want nil", input, got) - } - } -} - -func TestIsSubagentSessionKey(t *testing.T) { - tests := []struct { - input string - want bool - }{ - {"subagent:task-1", true}, - {"agent:main:subagent:task-1", true}, - {"agent:main:main", false}, - {"agent:main:telegram:direct:user123", false}, - {"", false}, - } - for _, tt := range tests { - if got := IsSubagentSessionKey(tt.input); got != tt.want { - t.Errorf("IsSubagentSessionKey(%q) = %v, want %v", tt.input, got, tt.want) - } - } -} diff --git a/pkg/session/allocator.go b/pkg/session/allocator.go index 6bf678deb..7045b93d6 100644 --- a/pkg/session/allocator.go +++ b/pkg/session/allocator.go @@ -32,7 +32,7 @@ type AllocationInput struct { func AllocateRouteSession(input AllocationInput) Allocation { scope := buildSessionScope(input) legacySessionAliases := buildLegacySessionAliases(input) - legacyMainSessionKey := strings.ToLower(routing.BuildAgentMainSessionKey(input.AgentID)) + legacyMainSessionKey := strings.ToLower(BuildLegacyMainAlias(input.AgentID)) return Allocation{ Scope: scope, SessionKey: BuildSessionKey(scope), @@ -85,7 +85,7 @@ func buildSessionScope(input AllocationInput) SessionScope { values["topic"] = "topic:" + strings.ToLower(topicID) } case "sender": - senderID := routing.CanonicalSessionIdentityID( + senderID := CanonicalSessionIdentityID( inbound.Channel, inbound.SenderID, input.SessionPolicy.IdentityLinks, @@ -107,11 +107,11 @@ func buildSessionScope(input AllocationInput) SessionScope { } func buildLegacySessionAliases(input AllocationInput) []string { - aliases := []string{strings.ToLower(routing.BuildAgentMainSessionKey(input.AgentID))} + aliases := []string{strings.ToLower(BuildLegacyMainAlias(input.AgentID))} inbound := input.Context if strings.EqualFold(strings.TrimSpace(inbound.ChatType), "direct") { - senderID := routing.CanonicalSessionIdentityID( + senderID := CanonicalSessionIdentityID( inbound.Channel, inbound.SenderID, input.SessionPolicy.IdentityLinks, @@ -119,20 +119,10 @@ func buildLegacySessionAliases(input AllocationInput) []string { if senderID == "" { return uniqueAliases(aliases) } - for _, dmScope := range []routing.DMScope{ - routing.DMScopePerPeer, - routing.DMScopePerChannelPeer, - routing.DMScopePerAccountChannelPeer, - } { - aliases = append(aliases, strings.ToLower(routing.BuildAgentPeerSessionKey(routing.SessionKeyParams{ - AgentID: input.AgentID, - Channel: inbound.Channel, - AccountID: inbound.Account, - Peer: &routing.RoutePeer{Kind: "direct", ID: senderID}, - DMScope: dmScope, - IdentityLinks: input.SessionPolicy.IdentityLinks, - }))) - } + aliases = append( + aliases, + BuildLegacyDirectAliases(input.AgentID, inbound.Channel, inbound.Account, senderID)..., + ) return uniqueAliases(aliases) } @@ -143,15 +133,12 @@ func buildLegacySessionAliases(input AllocationInput) []string { if topicID := strings.TrimSpace(inbound.TopicID); topicID != "" { peerID = peerID + "/" + topicID } - aliases = append(aliases, strings.ToLower(routing.BuildAgentPeerSessionKey(routing.SessionKeyParams{ - AgentID: input.AgentID, - Channel: inbound.Channel, - AccountID: inbound.Account, - Peer: &routing.RoutePeer{ - Kind: strings.ToLower(strings.TrimSpace(inbound.ChatType)), - ID: peerID, - }, - }))) + aliases = append(aliases, BuildLegacyPeerAlias( + input.AgentID, + inbound.Channel, + strings.ToLower(strings.TrimSpace(inbound.ChatType)), + peerID, + )) return uniqueAliases(aliases) } diff --git a/pkg/session/key.go b/pkg/session/key.go index 77dd115f5..6f1ee438f 100644 --- a/pkg/session/key.go +++ b/pkg/session/key.go @@ -5,9 +5,19 @@ import ( "encoding/hex" "fmt" "strings" + + "github.com/sipeed/picoclaw/pkg/routing" ) -const sessionKeyV1Prefix = "sk_v1_" +const ( + sessionKeyV1Prefix = "sk_v1_" + legacyAgentSessionKeyPrefix = "agent:" +) + +type ParsedLegacySessionKey struct { + AgentID string + Rest string +} // BuildOpaqueSessionKey returns a stable opaque session key derived from a // canonical alias string. The alias remains available through metadata for @@ -27,6 +37,129 @@ func IsOpaqueSessionKey(key string) bool { return strings.HasPrefix(strings.ToLower(strings.TrimSpace(key)), sessionKeyV1Prefix) } +func IsLegacyAgentSessionKey(key string) bool { + return strings.HasPrefix(strings.ToLower(strings.TrimSpace(key)), legacyAgentSessionKeyPrefix) +} + +func IsExplicitSessionKey(key string) bool { + return IsOpaqueSessionKey(key) || IsLegacyAgentSessionKey(key) +} + +func ParseLegacyAgentSessionKey(sessionKey string) *ParsedLegacySessionKey { + raw := strings.TrimSpace(sessionKey) + if raw == "" { + return nil + } + parts := strings.SplitN(raw, ":", 3) + if len(parts) < 3 || parts[0] != "agent" { + return nil + } + agentID := strings.TrimSpace(parts[1]) + rest := parts[2] + if agentID == "" || rest == "" { + return nil + } + return &ParsedLegacySessionKey{AgentID: agentID, Rest: rest} +} + +func BuildLegacyMainAlias(agentID string) string { + return fmt.Sprintf("agent:%s:main", routing.NormalizeAgentID(agentID)) +} + +// BuildMainSessionKey returns the canonical opaque main-session key for an +// agent. The corresponding legacy alias remains available via +// BuildLegacyMainAlias for compatibility and migration logic. +func BuildMainSessionKey(agentID string) string { + return BuildOpaqueSessionKey(BuildLegacyMainAlias(agentID)) +} + +func BuildLegacyDirectAliases(agentID, channel, account, peerID string) []string { + agentID = routing.NormalizeAgentID(agentID) + channel = normalizeLegacyChannel(channel) + account = routing.NormalizeAccountID(account) + peerID = strings.ToLower(strings.TrimSpace(peerID)) + if peerID == "" { + return nil + } + return []string{ + fmt.Sprintf("agent:%s:direct:%s", agentID, peerID), + fmt.Sprintf("agent:%s:%s:direct:%s", agentID, channel, peerID), + fmt.Sprintf("agent:%s:%s:%s:direct:%s", agentID, channel, account, peerID), + } +} + +func BuildLegacyPeerAlias(agentID, channel, peerKind, peerID string) string { + agentID = routing.NormalizeAgentID(agentID) + channel = normalizeLegacyChannel(channel) + peerKind = strings.ToLower(strings.TrimSpace(peerKind)) + if peerKind == "" { + peerKind = "unknown" + } + peerID = strings.ToLower(strings.TrimSpace(peerID)) + if peerID == "" { + peerID = "unknown" + } + return fmt.Sprintf("agent:%s:%s:%s:%s", agentID, channel, peerKind, peerID) +} + +// CanonicalSessionIdentityID collapses an identity using identity_links when +// possible, then returns a normalized lowercase identifier. +func CanonicalSessionIdentityID(channel, rawID string, identityLinks map[string][]string) string { + normalizedID := strings.TrimSpace(rawID) + if normalizedID == "" { + return "" + } + if linked := resolveLinkedPeerID(identityLinks, channel, normalizedID); linked != "" { + normalizedID = linked + } + return strings.ToLower(normalizedID) +} + +func normalizeLegacyChannel(channel string) string { + channel = strings.ToLower(strings.TrimSpace(channel)) + if channel == "" { + return "unknown" + } + return channel +} + +func resolveLinkedPeerID(identityLinks map[string][]string, channel, peerID string) string { + if len(identityLinks) == 0 { + return "" + } + peerID = strings.TrimSpace(peerID) + if peerID == "" { + return "" + } + + candidates := make(map[string]bool) + rawCandidate := strings.ToLower(peerID) + if rawCandidate != "" { + candidates[rawCandidate] = true + } + channel = strings.ToLower(strings.TrimSpace(channel)) + if channel != "" { + candidates[fmt.Sprintf("%s:%s", channel, rawCandidate)] = true + } + if idx := strings.Index(rawCandidate, ":"); idx > 0 && idx < len(rawCandidate)-1 { + candidates[rawCandidate[idx+1:]] = true + } + + for canonical, ids := range identityLinks { + canonicalName := strings.TrimSpace(canonical) + if canonicalName == "" { + continue + } + for _, id := range ids { + normalized := strings.ToLower(strings.TrimSpace(id)) + if normalized != "" && candidates[normalized] { + return canonicalName + } + } + } + return "" +} + // CanonicalScopeSignature returns a stable serialized representation of scope. func CanonicalScopeSignature(scope SessionScope) string { parts := []string{ diff --git a/pkg/session/key_test.go b/pkg/session/key_test.go new file mode 100644 index 000000000..ede38d468 --- /dev/null +++ b/pkg/session/key_test.go @@ -0,0 +1,72 @@ +package session + +import "testing" + +func TestIsExplicitSessionKey(t *testing.T) { + tests := []struct { + key string + want bool + }{ + {"sk_v1_abc", true}, + {"agent:main:direct:user123", true}, + {"custom-key", false}, + {"", false}, + } + + for _, tt := range tests { + if got := IsExplicitSessionKey(tt.key); got != tt.want { + t.Fatalf("IsExplicitSessionKey(%q) = %v, want %v", tt.key, got, tt.want) + } + } +} + +func TestParseLegacyAgentSessionKey(t *testing.T) { + parsed := ParseLegacyAgentSessionKey("agent:sales:telegram:direct:user123") + if parsed == nil { + t.Fatal("expected parsed legacy key, got nil") + } + if parsed.AgentID != "sales" { + t.Fatalf("AgentID = %q, want sales", parsed.AgentID) + } + if parsed.Rest != "telegram:direct:user123" { + t.Fatalf("Rest = %q, want telegram:direct:user123", parsed.Rest) + } + + if got := ParseLegacyAgentSessionKey("sk_v1_abc"); got != nil { + t.Fatalf("expected nil for opaque key, got %+v", got) + } +} + +func TestBuildLegacyDirectAliases(t *testing.T) { + aliases := BuildLegacyDirectAliases("Main", "Telegram", "BotA", "User123") + want := []string{ + "agent:main:direct:user123", + "agent:main:telegram:direct:user123", + "agent:main:telegram:bota:direct:user123", + } + if len(aliases) != len(want) { + t.Fatalf("len(aliases) = %d, want %d", len(aliases), len(want)) + } + for i := range want { + if aliases[i] != want[i] { + t.Fatalf("aliases[%d] = %q, want %q", i, aliases[i], want[i]) + } + } +} + +func TestBuildLegacyPeerAlias(t *testing.T) { + got := BuildLegacyPeerAlias("Main", "Slack", "channel", "C001") + if got != "agent:main:slack:channel:c001" { + t.Fatalf("BuildLegacyPeerAlias() = %q", got) + } +} + +func TestBuildMainSessionKey(t *testing.T) { + got := BuildMainSessionKey("Main") + if !IsOpaqueSessionKey(got) { + t.Fatalf("BuildMainSessionKey() = %q, want opaque key", got) + } + if got != BuildOpaqueSessionKey("agent:main:main") { + t.Fatalf("BuildMainSessionKey() = %q, want stable main-key hash", got) + } +} diff --git a/pkg/tools/cron.go b/pkg/tools/cron.go index c6ac3a129..30a8e92cd 100644 --- a/pkg/tools/cron.go +++ b/pkg/tools/cron.go @@ -311,8 +311,7 @@ func (t *CronTool) ExecuteJob(ctx context.Context, job *cron.CronJob) string { pubCtx, pubCancel := context.WithTimeout(context.Background(), 5*time.Second) defer pubCancel() t.msgBus.PublishOutbound(pubCtx, bus.OutboundMessage{ - Channel: channel, - ChatID: chatID, + Context: bus.NewOutboundContext(channel, chatID, ""), Content: output, }) return "ok" @@ -335,8 +334,7 @@ func (t *CronTool) ExecuteJob(ctx context.Context, job *cron.CronJob) string { pubCtx, pubCancel := context.WithTimeout(context.Background(), 5*time.Second) defer pubCancel() t.msgBus.PublishOutbound(pubCtx, bus.OutboundMessage{ - Channel: channel, - ChatID: chatID, + Context: bus.NewOutboundContext(channel, chatID, ""), Content: output, }) return "ok" From 53482a17bc17920e8cb3f2fd029b9aed2de9da7f Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 20:57:15 +0800 Subject: [PATCH 013/174] refactor(web): resolve pico sessions from scope metadata --- web/backend/api/session.go | 163 +++++++++++++++++++------------- web/backend/api/session_test.go | 12 +-- 2 files changed, 102 insertions(+), 73 deletions(-) diff --git a/web/backend/api/session.go b/web/backend/api/session.go index d00fa84c8..052f085d6 100644 --- a/web/backend/api/session.go +++ b/web/backend/api/session.go @@ -44,25 +44,19 @@ type sessionListItem struct { Updated string `json:"updated"` } -// picoSessionPrefix is the key prefix used by the gateway's routing for Pico -// channel sessions. The full key format is: -// -// agent:main:pico:direct:pico: -// -// The sanitized filename replaces ':' with '_', so on disk it becomes: -// -// agent_main_pico_direct_pico_.json +// legacyPicoSessionPrefix is the legacy key prefix used by older Pico JSON/JSONL +// sessions before structured scope metadata existed. const ( - picoSessionPrefix = "agent:main:pico:direct:pico:" + legacyPicoSessionPrefix = "agent:main:pico:direct:pico:" maxSessionJSONLLineSize = 10 * 1024 * 1024 // 10 MB maxSessionTitleRunes = 60 ) -// extractPicoSessionID extracts the session UUID from a full session key. +// extractLegacyPicoSessionID extracts the session UUID from an old Pico key. // Returns the UUID and true if the key matches the Pico session pattern. -func extractPicoSessionID(key string) (string, bool) { - if strings.HasPrefix(key, picoSessionPrefix) { - return strings.TrimPrefix(key, picoSessionPrefix), true +func extractLegacyPicoSessionID(key string) (string, bool) { + if strings.HasPrefix(key, legacyPicoSessionPrefix) { + return strings.TrimPrefix(key, legacyPicoSessionPrefix), true } return "", false } @@ -74,8 +68,7 @@ func sanitizeSessionKey(key string) string { return key } -func (h *Handler) readLegacySession(dir, sessionID string) (sessionFile, error) { - path := filepath.Join(dir, sanitizeSessionKey(picoSessionPrefix+sessionID)+".json") +func (h *Handler) readLegacySession(path string) (sessionFile, error) { data, err := os.ReadFile(path) if err != nil { return sessionFile{}, err @@ -184,6 +177,11 @@ type picoJSONLSessionRef struct { Key string } +type picoLegacySessionRef struct { + ID string + Path string +} + func extractPicoSessionIDFromScope(scope session.SessionScope) (string, bool) { if !strings.EqualFold(strings.TrimSpace(scope.Channel), "pico") { return "", false @@ -208,15 +206,15 @@ func extractPicoSessionIDFromScope(scope session.SessionScope) (string, bool) { } func sessionRefFromMeta(meta memory.SessionMeta) (picoJSONLSessionRef, bool) { - if sessionID, ok := extractPicoSessionID(meta.Key); ok { - return picoJSONLSessionRef{ID: sessionID, Key: meta.Key}, true - } - for _, alias := range meta.Aliases { - if sessionID, ok := extractPicoSessionID(alias); ok { + if len(meta.Scope) == 0 { + if sessionID, ok := extractLegacyPicoSessionID(meta.Key); ok { return picoJSONLSessionRef{ID: sessionID, Key: meta.Key}, true } - } - if len(meta.Scope) == 0 { + for _, alias := range meta.Aliases { + if sessionID, ok := extractLegacyPicoSessionID(alias); ok { + return picoJSONLSessionRef{ID: sessionID, Key: meta.Key}, true + } + } return picoJSONLSessionRef{}, false } var scope session.SessionScope @@ -225,6 +223,14 @@ func sessionRefFromMeta(meta memory.SessionMeta) (picoJSONLSessionRef, bool) { } sessionID, ok := extractPicoSessionIDFromScope(scope) if !ok { + if legacySessionID, ok := extractLegacyPicoSessionID(meta.Key); ok { + return picoJSONLSessionRef{ID: legacySessionID, Key: meta.Key}, true + } + for _, alias := range meta.Aliases { + if legacySessionID, ok := extractLegacyPicoSessionID(alias); ok { + return picoJSONLSessionRef{ID: legacySessionID, Key: meta.Key}, true + } + } return picoJSONLSessionRef{}, false } return picoJSONLSessionRef{ID: sessionID, Key: meta.Key}, true @@ -273,6 +279,51 @@ func (h *Handler) findPicoJSONLSession(dir, sessionID string) (picoJSONLSessionR return picoJSONLSessionRef{}, os.ErrNotExist } +func (h *Handler) findLegacyPicoSessions(dir string) ([]picoLegacySessionRef, error) { + entries, err := os.ReadDir(dir) + if err != nil { + return nil, err + } + + refs := make([]picoLegacySessionRef, 0) + seen := make(map[string]struct{}) + for _, entry := range entries { + if entry.IsDir() || filepath.Ext(entry.Name()) != ".json" { + continue + } + + path := filepath.Join(dir, entry.Name()) + sess, err := h.readLegacySession(path) + if err != nil || isEmptySession(sess) { + continue + } + + sessionID, ok := extractLegacyPicoSessionID(sess.Key) + if !ok || sessionID == "" { + continue + } + if _, exists := seen[sessionID]; exists { + continue + } + seen[sessionID] = struct{}{} + refs = append(refs, picoLegacySessionRef{ID: sessionID, Path: path}) + } + return refs, nil +} + +func (h *Handler) findLegacyPicoSession(dir, sessionID string) (picoLegacySessionRef, error) { + refs, err := h.findLegacyPicoSessions(dir) + if err != nil { + return picoLegacySessionRef{}, err + } + for _, ref := range refs { + if ref.ID == sessionID { + return ref, nil + } + } + return picoLegacySessionRef{}, os.ErrNotExist +} + func buildSessionListItem(sessionID string, sess sessionFile) sessionListItem { preview := "" for _, msg := range sess.Messages { @@ -365,8 +416,7 @@ func (h *Handler) handleListSessions(w http.ResponseWriter, r *http.Request) { return } - entries, err := os.ReadDir(dir) - if err != nil { + if _, err := os.ReadDir(dir); err != nil { // Directory doesn't exist yet = no sessions w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode([]sessionListItem{}) @@ -387,42 +437,18 @@ func (h *Handler) handleListSessions(w http.ResponseWriter, r *http.Request) { } } - for _, entry := range entries { - if entry.IsDir() { - continue + if legacyRefs, findErr := h.findLegacyPicoSessions(dir); findErr == nil { + for _, ref := range legacyRefs { + if _, exists := seen[ref.ID]; exists { + continue + } + sess, loadErr := h.readLegacySession(ref.Path) + if loadErr != nil || isEmptySession(sess) { + continue + } + seen[ref.ID] = struct{}{} + items = append(items, buildSessionListItem(ref.ID, sess)) } - name := entry.Name() - if strings.HasSuffix(name, ".meta.json") || filepath.Ext(name) != ".json" { - continue - } - - base := strings.TrimSuffix(name, ".json") - if _, statErr := os.Stat(filepath.Join(dir, base+".jsonl")); statErr == nil { - continue - } - - data, err := os.ReadFile(filepath.Join(dir, name)) - if err != nil { - continue - } - - var sess sessionFile - if err := json.Unmarshal(data, &sess); err != nil { - continue - } - if isEmptySession(sess) { - continue - } - sessionID, ok := extractPicoSessionID(sess.Key) - if !ok { - continue - } - if _, exists := seen[sessionID]; exists { - continue - } - - seen[sessionID] = struct{}{} - items = append(items, buildSessionListItem(sessionID, sess)) } // Sort by updated descending (most recent first) @@ -487,7 +513,9 @@ func (h *Handler) handleGetSession(w http.ResponseWriter, r *http.Request) { } if err != nil { if errors.Is(err, os.ErrNotExist) { - sess, err = h.readLegacySession(dir, sessionID) + if legacyRef, legacyErr := h.findLegacyPicoSession(dir, sessionID); legacyErr == nil { + sess, err = h.readLegacySession(legacyRef.Path) + } if err == nil && isEmptySession(sess) { err = os.ErrNotExist } @@ -560,14 +588,15 @@ func (h *Handler) handleDeleteSession(w http.ResponseWriter, r *http.Request) { } } - legacyPath := filepath.Join(dir, sanitizeSessionKey(picoSessionPrefix+sessionID)+".json") - if err := os.Remove(legacyPath); err != nil { - if !os.IsNotExist(err) { - http.Error(w, "failed to delete session", http.StatusInternalServerError) - return + if legacyRef, err := h.findLegacyPicoSession(dir, sessionID); err == nil { + if err := os.Remove(legacyRef.Path); err != nil { + if !os.IsNotExist(err) { + http.Error(w, "failed to delete session", http.StatusInternalServerError) + return + } + } else { + removed = true } - } else { - removed = true } if !removed { diff --git a/web/backend/api/session_test.go b/web/backend/api/session_test.go index eeb477c66..40e53b0b0 100644 --- a/web/backend/api/session_test.go +++ b/web/backend/api/session_test.go @@ -39,7 +39,7 @@ func TestHandleListSessions_JSONLStorage(t *testing.T) { t.Fatalf("NewJSONLStore() error = %v", err) } - sessionKey := picoSessionPrefix + "history-jsonl" + sessionKey := legacyPicoSessionPrefix + "history-jsonl" if err := store.AddFullMessage(nil, sessionKey, providers.Message{ Role: "user", Content: "Explain why the history API is empty after migration.", @@ -105,7 +105,7 @@ func TestHandleListSessions_TitleUsesTrimmedSummary(t *testing.T) { t.Fatalf("NewJSONLStore() error = %v", err) } - sessionKey := picoSessionPrefix + "summary-title" + sessionKey := legacyPicoSessionPrefix + "summary-title" if err := store.AddFullMessage(nil, sessionKey, providers.Message{ Role: "user", Content: "fallback preview", @@ -161,7 +161,7 @@ func TestHandleGetSession_JSONLStorage(t *testing.T) { t.Fatalf("NewJSONLStore() error = %v", err) } - sessionKey := picoSessionPrefix + "detail-jsonl" + sessionKey := legacyPicoSessionPrefix + "detail-jsonl" for _, msg := range []providers.Message{ {Role: "user", Content: "first"}, {Role: "assistant", Content: "second"}, @@ -302,7 +302,7 @@ func TestHandleDeleteSession_JSONLStorage(t *testing.T) { t.Fatalf("NewJSONLStore() error = %v", err) } - sessionKey := picoSessionPrefix + "delete-jsonl" + sessionKey := legacyPicoSessionPrefix + "delete-jsonl" if err := store.AddFullMessage(nil, sessionKey, providers.Message{ Role: "user", Content: "delete me", @@ -339,7 +339,7 @@ func TestHandleGetSession_LegacyJSONFallback(t *testing.T) { dir := sessionsTestDir(t, configPath) manager := session.NewSessionManager(dir) - sessionKey := picoSessionPrefix + "legacy-json" + sessionKey := legacyPicoSessionPrefix + "legacy-json" manager.AddMessage(sessionKey, "user", "legacy user") manager.AddMessage(sessionKey, "assistant", "legacy assistant") if err := manager.Save(sessionKey); err != nil { @@ -364,7 +364,7 @@ func TestHandleSessions_FiltersEmptyJSONLFiles(t *testing.T) { defer cleanup() dir := sessionsTestDir(t, configPath) - base := filepath.Join(dir, sanitizeSessionKey(picoSessionPrefix+"empty-jsonl")) + base := filepath.Join(dir, sanitizeSessionKey(legacyPicoSessionPrefix+"empty-jsonl")) if err := os.WriteFile(base+".jsonl", []byte{}, 0o644); err != nil { t.Fatalf("WriteFile(jsonl) error = %v", err) } From 3a9d1fc6fd3687b91fb2356c29a3ce5225dc1f3a Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 21:34:24 +0800 Subject: [PATCH 014/174] test(channels): update inbound context assertions --- pkg/channels/dingtalk/dingtalk_test.go | 13 ++++++---- pkg/channels/qq/qq_test.go | 20 +++++++------- pkg/channels/telegram/telegram_test.go | 36 +++++++------------------- pkg/channels/wecom/wecom_test.go | 8 +++--- 4 files changed, 32 insertions(+), 45 deletions(-) diff --git a/pkg/channels/dingtalk/dingtalk_test.go b/pkg/channels/dingtalk/dingtalk_test.go index 437616456..c9ab4c196 100644 --- a/pkg/channels/dingtalk/dingtalk_test.go +++ b/pkg/channels/dingtalk/dingtalk_test.go @@ -65,8 +65,8 @@ func TestOnChatBotMessageReceived_GroupMentionOnlyUsesIsInAtListAndStripsMention if inbound.ChatID != "group-abc" { t.Fatalf("chat_id=%q", inbound.ChatID) } - if inbound.Peer.Kind != "group" || inbound.Peer.ID != "group-abc" { - t.Fatalf("peer=%+v", inbound.Peer) + if inbound.Context.ChatType != "group" { + t.Fatalf("chat_type=%q", inbound.Context.ChatType) } if inbound.Content != "/help" { t.Fatalf("content=%q", inbound.Content) @@ -93,12 +93,15 @@ func TestOnChatBotMessageReceived_DirectFallbackSenderIDUsesConversationID(t *te if inbound.ChatID != "conv-direct-42" { t.Fatalf("chat_id=%q", inbound.ChatID) } - if inbound.Peer.Kind != "direct" || inbound.Peer.ID != "openid-user-42" { - t.Fatalf("peer=%+v", inbound.Peer) + if inbound.Context.ChatType != "direct" { + t.Fatalf("chat_type=%q", inbound.Context.ChatType) } - if inbound.SenderID != "dingtalk:openid-user-42" { + if inbound.SenderID != "openid-user-42" { t.Fatalf("sender_id=%q", inbound.SenderID) } + if inbound.Sender.CanonicalID != "dingtalk:openid-user-42" { + t.Fatalf("sender canonical_id=%q", inbound.Sender.CanonicalID) + } if _, ok := ch.sessionWebhooks.Load("conv-direct-42"); !ok { t.Fatal("expected session webhook keyed by conversation_id") diff --git a/pkg/channels/qq/qq_test.go b/pkg/channels/qq/qq_test.go index 83a912cd7..905532f01 100644 --- a/pkg/channels/qq/qq_test.go +++ b/pkg/channels/qq/qq_test.go @@ -50,15 +50,15 @@ func TestHandleC2CMessage_IncludesAccountIDMetadata(t *testing.T) { case <-ctx.Done(): t.Fatal("timeout waiting for inbound message") return - case inbound, ok := <-messageBus.InboundChan(): - if !ok { - t.Fatal("expected inbound message") + case inbound, ok := <-messageBus.InboundChan(): + if !ok { + t.Fatal("expected inbound message") + } + if inbound.Context.Raw["account_id"] != "7750283E123456" { + t.Fatalf("account_id raw = %q, want %q", inbound.Context.Raw["account_id"], "7750283E123456") + } + return } - if inbound.Metadata["account_id"] != "7750283E123456" { - t.Fatalf("account_id metadata = %q, want %q", inbound.Metadata["account_id"], "7750283E123456") - } - return - } } } @@ -165,8 +165,8 @@ func TestHandleGroupATMessage_AttachmentOnlyPublishesMedia(t *testing.T) { if !strings.HasPrefix(inbound.Media[0], "media://") { t.Fatalf("inbound.Media[0] = %q, want media:// ref", inbound.Media[0]) } - if inbound.Peer.Kind != "group" || inbound.Peer.ID != "group-1" { - t.Fatalf("inbound.Peer = %+v, want group/group-1", inbound.Peer) + if inbound.Context.ChatType != "group" { + t.Fatalf("inbound.Context.ChatType = %q, want group", inbound.Context.ChatType) } } diff --git a/pkg/channels/telegram/telegram_test.go b/pkg/channels/telegram/telegram_test.go index 4f7a2600b..0b5d21e2b 100644 --- a/pkg/channels/telegram/telegram_test.go +++ b/pkg/channels/telegram/telegram_test.go @@ -556,16 +556,10 @@ func TestHandleMessage_ForumTopic_SetsMetadata(t *testing.T) { inbound, ok := <-messageBus.InboundChan() 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"]) + // ChatID remains the parent chat; TopicID isolates the sub-conversation. + assert.Equal(t, "-1001234567890", inbound.ChatID) + assert.Equal(t, "group", inbound.Context.ChatType) + assert.Equal(t, "42", inbound.Context.TopicID) } func TestHandleMessage_NoForum_NoThreadMetadata(t *testing.T) { @@ -598,13 +592,8 @@ func TestHandleMessage_NoForum_NoThreadMetadata(t *testing.T) { // 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"]) + assert.Equal(t, "group", inbound.Context.ChatType) + assert.Empty(t, inbound.Context.TopicID) } func TestHandleMessage_ReplyThread_NonForum_NoIsolation(t *testing.T) { @@ -641,13 +630,8 @@ func TestHandleMessage_ReplyThread_NonForum_NoIsolation(t *testing.T) { // 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"]) + assert.Equal(t, "group", inbound.Context.ChatType) + assert.Empty(t, inbound.Context.TopicID) } func assertHandleMessageQuotedUserReply( @@ -700,7 +684,7 @@ func assertHandleMessageQuotedUserReply( inbound, ok := <-messageBus.InboundChan() require.True(t, ok) - assert.Equal(t, strconv.Itoa(replyMessageID), inbound.Metadata["reply_to_message_id"]) + assert.Equal(t, strconv.Itoa(replyMessageID), inbound.Context.ReplyToMessageID) assert.Equal(t, expectedContent, inbound.Content) } @@ -786,7 +770,7 @@ func TestHandleMessage_ReplyToOwnBotMessage_UsesAssistantRole(t *testing.T) { inbound, ok := <-messageBus.InboundChan() require.True(t, ok) - assert.Equal(t, "101", inbound.Metadata["reply_to_message_id"]) + assert.Equal(t, "101", inbound.Context.ReplyToMessageID) assert.Equal( t, "[quoted assistant message from afjcjsbx_picoclaw_bot]: Fatto! Ho creato il file notizie_2026_03_28.md\n\nti ricordi questo file?", diff --git a/pkg/channels/wecom/wecom_test.go b/pkg/channels/wecom/wecom_test.go index b3a87e246..f71616fcb 100644 --- a/pkg/channels/wecom/wecom_test.go +++ b/pkg/channels/wecom/wecom_test.go @@ -50,11 +50,11 @@ func TestDispatchIncoming_UsesActualChatIDAndStoresReqIDRoute(t *testing.T) { if inbound.MessageID != "msg-1" { t.Fatalf("inbound MessageID = %q, want msg-1", inbound.MessageID) } - if inbound.Peer.ID != "chat-1" { - t.Fatalf("inbound Peer.ID = %q, want chat-1", inbound.Peer.ID) + if inbound.Context.ChatType != "direct" { + t.Fatalf("inbound Context.ChatType = %q, want direct", inbound.Context.ChatType) } - if inbound.Metadata["req_id"] != "req-1" { - t.Fatalf("inbound req_id = %q, want req-1", inbound.Metadata["req_id"]) + if inbound.Context.ReplyHandles["req_id"] != "req-1" { + t.Fatalf("inbound req_id = %q, want req-1", inbound.Context.ReplyHandles["req_id"]) } default: t.Fatal("expected inbound message to be published") From 19a01d426453a7bbad1b2e07b24a91959cb3c26f Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 21:34:39 +0800 Subject: [PATCH 015/174] refactor(routing): remove legacy bindings config --- pkg/agent/loop_test.go | 39 +++---- pkg/config/config.go | 19 ---- pkg/config/config_old.go | 2 - pkg/config/config_test.go | 20 +--- pkg/config/defaults.go | 1 - pkg/routing/route.go | 215 ++---------------------------------- pkg/routing/route_test.go | 225 +++----------------------------------- 7 files changed, 44 insertions(+), 477 deletions(-) diff --git a/pkg/agent/loop_test.go b/pkg/agent/loop_test.go index 4aa356f88..f288f1f2b 100644 --- a/pkg/agent/loop_test.go +++ b/pkg/agent/loop_test.go @@ -755,12 +755,12 @@ func TestAppendEventContextFields_IncludesInboundRouteAndScope(t *testing.T) { SenderID: "U123", Mentioned: true, }, - Route: &routing.ResolvedRoute{ - AgentID: "support", - Channel: "slack", - AccountID: "workspace-a", - MatchedBy: "binding.team", - SessionPolicy: routing.SessionPolicy{ + Route: &routing.ResolvedRoute{ + AgentID: "support", + Channel: "slack", + AccountID: "workspace-a", + MatchedBy: "default", + SessionPolicy: routing.SessionPolicy{ Dimensions: []string{"chat", "sender"}, IdentityLinks: map[string][]string{ "canonical-user": {"slack:U123"}, @@ -786,8 +786,8 @@ func TestAppendEventContextFields_IncludesInboundRouteAndScope(t *testing.T) { if fields["inbound_topic_id"] != "thread-42" { t.Fatalf("inbound_topic_id = %v, want thread-42", fields["inbound_topic_id"]) } - if fields["route_matched_by"] != "binding.team" { - t.Fatalf("route_matched_by = %v, want binding.team", fields["route_matched_by"]) + if fields["route_matched_by"] != "default" { + t.Fatalf("route_matched_by = %v, want default", fields["route_matched_by"]) } if fields["route_dimensions"] != "chat,sender" { t.Fatalf("route_dimensions = %v, want chat,sender", fields["route_dimensions"]) @@ -806,7 +806,7 @@ func TestAppendEventContextFields_IncludesInboundRouteAndScope(t *testing.T) { } } -func TestResolveMessageRoute_UsesInboundContextAccountAndSpace(t *testing.T) { +func TestResolveMessageRoute_UsesInboundContextAccount(t *testing.T) { tmpDir := t.TempDir() cfg := &config.Config{ Agents: config.AgentsConfig{ @@ -819,16 +819,6 @@ func TestResolveMessageRoute_UsesInboundContextAccountAndSpace(t *testing.T) { {ID: "work"}, }, }, - Bindings: []config.AgentBinding{ - { - AgentID: "work", - Match: config.BindingMatch{ - Channel: "slack", - AccountID: "*", - TeamID: "T001", - }, - }, - }, Session: config.SessionConfig{ Dimensions: []string{"sender"}, }, @@ -852,11 +842,14 @@ func TestResolveMessageRoute_UsesInboundContextAccountAndSpace(t *testing.T) { if err != nil { t.Fatalf("resolveMessageRoute() error = %v", err) } - if route.AgentID != "work" { - t.Fatalf("AgentID = %q, want work", route.AgentID) + if route.AgentID != "main" { + t.Fatalf("AgentID = %q, want main", route.AgentID) } - if route.MatchedBy != "binding.team" { - t.Fatalf("MatchedBy = %q, want binding.team", route.MatchedBy) + if route.MatchedBy != "default" { + t.Fatalf("MatchedBy = %q, want default", route.MatchedBy) + } + if route.AccountID != "workspace-a" { + t.Fatalf("AccountID = %q, want workspace-a", route.AccountID) } } diff --git a/pkg/config/config.go b/pkg/config/config.go index 014c90045..739980912 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -27,7 +27,6 @@ const CurrentVersion = 2 type Config struct { Version int `json:"version" yaml:"-"` // Config schema version for migration Agents AgentsConfig `json:"agents" yaml:"-"` - Bindings []AgentBinding `json:"bindings,omitempty" yaml:"-"` Session SessionConfig `json:"session,omitempty" yaml:"-"` Channels ChannelsConfig `json:"channels" yaml:"channels"` ModelList SecureModelList `json:"model_list" yaml:"model_list"` // New model-centric provider configuration @@ -176,24 +175,6 @@ type SubagentsConfig struct { Model *AgentModelConfig `json:"model,omitempty"` } -type PeerMatch struct { - Kind string `json:"kind"` - ID string `json:"id"` -} - -type BindingMatch struct { - Channel string `json:"channel"` - AccountID string `json:"account_id,omitempty"` - Peer *PeerMatch `json:"peer,omitempty"` - GuildID string `json:"guild_id,omitempty"` - TeamID string `json:"team_id,omitempty"` -} - -type AgentBinding struct { - AgentID string `json:"agent_id"` - Match BindingMatch `json:"match"` -} - type SessionConfig struct { Dimensions []string `json:"dimensions,omitempty"` IdentityLinks map[string][]string `json:"identity_links,omitempty"` diff --git a/pkg/config/config_old.go b/pkg/config/config_old.go index 150275aac..0b10fbf0b 100644 --- a/pkg/config/config_old.go +++ b/pkg/config/config_old.go @@ -47,7 +47,6 @@ type agentsConfigV0 struct { // It is unexported since it's only used internally for migration. type configV0 struct { Agents agentsConfigV0 `json:"agents"` - Bindings []AgentBinding `json:"bindings,omitempty"` Session SessionConfig `json:"session,omitempty"` Channels channelsConfigV0 `json:"channels"` Providers providersConfigV0 `json:"providers,omitempty"` @@ -701,7 +700,6 @@ func (c *configV0) Migrate() (*Config, error) { cfg.Agents.Defaults.Routing = c.Agents.Defaults.Routing // Copy other top-level fields - cfg.Bindings = c.Bindings cfg.Session = c.Session cfg.Channels = c.Channels.ToChannelsConfig() cfg.Gateway = c.Gateway diff --git a/pkg/config/config_test.go b/pkg/config/config_test.go index e8ebf1cfe..58c1461f5 100644 --- a/pkg/config/config_test.go +++ b/pkg/config/config_test.go @@ -175,20 +175,9 @@ func TestAgentConfig_FullParse(t *testing.T) { t.Errorf("support.Subagents = %+v", support.Subagents) } - if len(cfg.Bindings) != 1 { - t.Fatalf("bindings len = %d, want 1", len(cfg.Bindings)) - } - binding := cfg.Bindings[0] - if binding.AgentID != "support" || binding.Match.Channel != "telegram" { - t.Errorf("binding = %+v", binding) - } - if binding.Match.Peer == nil || binding.Match.Peer.Kind != "direct" || binding.Match.Peer.ID != "user123" { - t.Errorf("binding.Match.Peer = %+v", binding.Match.Peer) - } - - if len(cfg.Session.Dimensions) != 1 || cfg.Session.Dimensions[0] != "sender" { - t.Errorf("Session.Dimensions = %v", cfg.Session.Dimensions) - } + if len(cfg.Session.Dimensions) != 1 || cfg.Session.Dimensions[0] != "sender" { + t.Errorf("Session.Dimensions = %v", cfg.Session.Dimensions) + } if len(cfg.Session.IdentityLinks) != 1 { t.Errorf("Session.IdentityLinks = %v", cfg.Session.IdentityLinks) } @@ -218,9 +207,6 @@ func TestConfig_BackwardCompat_NoAgentsList(t *testing.T) { if len(cfg.Agents.List) != 0 { t.Errorf("agents.list should be empty for backward compat, got %d", len(cfg.Agents.List)) } - if len(cfg.Bindings) != 0 { - t.Errorf("bindings should be empty, got %d", len(cfg.Bindings)) - } } // TestDefaultConfig_HeartbeatEnabled verifies heartbeat is enabled by default diff --git a/pkg/config/defaults.go b/pkg/config/defaults.go index 58cd05088..9165045d4 100644 --- a/pkg/config/defaults.go +++ b/pkg/config/defaults.go @@ -35,7 +35,6 @@ func DefaultConfig() *Config { SplitOnMarker: false, }, }, - Bindings: []AgentBinding{}, Session: SessionConfig{ Dimensions: []string{"chat"}, }, diff --git a/pkg/routing/route.go b/pkg/routing/route.go index 88a0006da..6300460f8 100644 --- a/pkg/routing/route.go +++ b/pkg/routing/route.go @@ -13,21 +13,16 @@ type SessionPolicy struct { IdentityLinks map[string][]string } -type RoutePeer struct { - Kind string - ID string -} - // ResolvedRoute is the result of agent routing. type ResolvedRoute struct { AgentID string Channel string AccountID string SessionPolicy SessionPolicy - MatchedBy string // "binding.peer", "binding.peer.parent", "binding.guild", "binding.team", "binding.account", "binding.channel", "default" + MatchedBy string // currently always "default" until the new binding system lands } -// RouteResolver determines which agent handles a message based on config bindings. +// RouteResolver determines which agent handles a message. type RouteResolver struct { cfg *config.Config } @@ -40,167 +35,17 @@ func NewRouteResolver(cfg *config.Config) *RouteResolver { // ResolveRoute determines which agent handles the message from a normalized // inbound context and returns the session policy that should be used to // allocate session state. -// Implements the 7-level priority cascade: -// peer > parent_peer > guild > team > account > channel_wildcard > default func (r *RouteResolver) ResolveRoute(inbound bus.InboundContext) ResolvedRoute { channel := strings.ToLower(strings.TrimSpace(inbound.Channel)) accountID := NormalizeAccountID(inbound.Account) - peer := routePeerFromContext(inbound) - sessionPolicy := r.sessionPolicy() - - bindings := r.filterBindings(channel, accountID) - - choose := func(agentID string, matchedBy string) ResolvedRoute { - resolvedAgentID := r.pickAgentID(agentID) - return ResolvedRoute{ - AgentID: resolvedAgentID, - Channel: channel, - AccountID: accountID, - SessionPolicy: sessionPolicy, - MatchedBy: matchedBy, - } + return ResolvedRoute{ + AgentID: r.pickAgentID(r.resolveDefaultAgentID()), + Channel: channel, + AccountID: accountID, + SessionPolicy: r.sessionPolicy(), + MatchedBy: "default", } - - // Priority 1: Peer binding - if peer != nil && strings.TrimSpace(peer.ID) != "" { - if match := r.findPeerMatch(bindings, peer); match != nil { - return choose(match.AgentID, "binding.peer") - } - } - - // Priority 2: Parent peer binding - parentPeer := parentPeerFromContext(inbound) - if parentPeer != nil && strings.TrimSpace(parentPeer.ID) != "" { - if match := r.findPeerMatch(bindings, parentPeer); match != nil { - return choose(match.AgentID, "binding.peer.parent") - } - } - - // Priority 3: Guild binding - guildID := routeGuildIDFromContext(inbound) - if guildID != "" { - if match := r.findGuildMatch(bindings, guildID); match != nil { - return choose(match.AgentID, "binding.guild") - } - } - - // Priority 4: Team binding - teamID := routeTeamIDFromContext(inbound) - if teamID != "" { - if match := r.findTeamMatch(bindings, teamID); match != nil { - return choose(match.AgentID, "binding.team") - } - } - - // Priority 5: Account binding - if match := r.findAccountMatch(bindings); match != nil { - return choose(match.AgentID, "binding.account") - } - - // Priority 6: Channel wildcard binding - if match := r.findChannelWildcardMatch(bindings); match != nil { - return choose(match.AgentID, "binding.channel") - } - - // Priority 7: Default agent - return choose(r.resolveDefaultAgentID(), "default") -} - -func (r *RouteResolver) filterBindings(channel, accountID string) []config.AgentBinding { - var filtered []config.AgentBinding - for _, b := range r.cfg.Bindings { - matchChannel := strings.ToLower(strings.TrimSpace(b.Match.Channel)) - if matchChannel == "" || matchChannel != channel { - continue - } - if !matchesAccountID(b.Match.AccountID, accountID) { - continue - } - filtered = append(filtered, b) - } - return filtered -} - -func matchesAccountID(matchAccountID, actual string) bool { - trimmed := strings.TrimSpace(matchAccountID) - if trimmed == "" { - return actual == DefaultAccountID - } - if trimmed == "*" { - return true - } - return strings.ToLower(trimmed) == strings.ToLower(actual) -} - -func (r *RouteResolver) findPeerMatch(bindings []config.AgentBinding, peer *RoutePeer) *config.AgentBinding { - for i := range bindings { - b := &bindings[i] - if b.Match.Peer == nil { - continue - } - peerKind := strings.ToLower(strings.TrimSpace(b.Match.Peer.Kind)) - peerID := strings.TrimSpace(b.Match.Peer.ID) - if peerKind == "" || peerID == "" { - continue - } - if peerKind == strings.ToLower(peer.Kind) && peerID == peer.ID { - return b - } - } - return nil -} - -func (r *RouteResolver) findGuildMatch(bindings []config.AgentBinding, guildID string) *config.AgentBinding { - for i := range bindings { - b := &bindings[i] - matchGuild := strings.TrimSpace(b.Match.GuildID) - if matchGuild != "" && matchGuild == guildID { - return &bindings[i] - } - } - return nil -} - -func (r *RouteResolver) findTeamMatch(bindings []config.AgentBinding, teamID string) *config.AgentBinding { - for i := range bindings { - b := &bindings[i] - matchTeam := strings.TrimSpace(b.Match.TeamID) - if matchTeam != "" && matchTeam == teamID { - return &bindings[i] - } - } - return nil -} - -func (r *RouteResolver) findAccountMatch(bindings []config.AgentBinding) *config.AgentBinding { - for i := range bindings { - b := &bindings[i] - accountID := strings.TrimSpace(b.Match.AccountID) - if accountID == "*" { - continue - } - if b.Match.Peer != nil || b.Match.GuildID != "" || b.Match.TeamID != "" { - continue - } - return &bindings[i] - } - return nil -} - -func (r *RouteResolver) findChannelWildcardMatch(bindings []config.AgentBinding) *config.AgentBinding { - for i := range bindings { - b := &bindings[i] - accountID := strings.TrimSpace(b.Match.AccountID) - if accountID != "*" { - continue - } - if b.Match.Peer != nil || b.Match.GuildID != "" || b.Match.TeamID != "" { - continue - } - return &bindings[i] - } - return nil } func (r *RouteResolver) pickAgentID(agentID string) string { @@ -273,46 +118,6 @@ func normalizeSessionDimensions(dimensions []string) []string { return normalized } -func routePeerFromContext(ctx bus.InboundContext) *RoutePeer { - peerKind := normalizeChannel(strings.TrimSpace(ctx.ChatType)) - if peerKind == "" || peerKind == "unknown" { - return nil - } - - peerID := strings.TrimSpace(ctx.ChatID) - if peerKind == "direct" && peerID == "" { - peerID = strings.TrimSpace(ctx.SenderID) - } - if peerID == "" { - return nil - } - - return &RoutePeer{Kind: peerKind, ID: peerID} -} - -func parentPeerFromContext(ctx bus.InboundContext) *RoutePeer { - if topicID := strings.TrimSpace(ctx.TopicID); topicID != "" { - return &RoutePeer{Kind: "topic", ID: topicID} - } - return nil -} - -func routeGuildIDFromContext(ctx bus.InboundContext) string { - if strings.EqualFold(strings.TrimSpace(ctx.SpaceType), "guild") { - return strings.TrimSpace(ctx.SpaceID) - } - return "" -} - -func routeTeamIDFromContext(ctx bus.InboundContext) string { - switch strings.ToLower(strings.TrimSpace(ctx.SpaceType)) { - case "team", "workspace": - return strings.TrimSpace(ctx.SpaceID) - default: - return "" - } -} - func cloneIdentityLinks(src map[string][]string) map[string][]string { if len(src) == 0 { return nil @@ -325,7 +130,3 @@ func cloneIdentityLinks(src map[string][]string) map[string][]string { } return cloned } - -func normalizeChannel(value string) string { - return strings.ToLower(strings.TrimSpace(value)) -} diff --git a/pkg/routing/route_test.go b/pkg/routing/route_test.go index 46a0f9f13..b4e3d6406 100644 --- a/pkg/routing/route_test.go +++ b/pkg/routing/route_test.go @@ -7,7 +7,7 @@ import ( "github.com/sipeed/picoclaw/pkg/config" ) -func testConfig(agents []config.AgentConfig, bindings []config.AgentBinding) *config.Config { +func testConfig(agents []config.AgentConfig) *config.Config { return &config.Config{ Agents: config.AgentsConfig{ Defaults: config.AgentDefaults{ @@ -16,7 +16,6 @@ func testConfig(agents []config.AgentConfig, bindings []config.AgentBinding) *co }, List: agents, }, - Bindings: bindings, Session: config.SessionConfig{ Dimensions: []string{"sender"}, }, @@ -24,7 +23,7 @@ func testConfig(agents []config.AgentConfig, bindings []config.AgentBinding) *co } func TestResolveRoute_DefaultAgent_NoBindings(t *testing.T) { - cfg := testConfig(nil, nil) + cfg := testConfig(nil) r := NewRouteResolver(cfg) route := r.ResolveRoute(bus.InboundContext{ @@ -47,209 +46,28 @@ func TestResolveRoute_DefaultAgent_NoBindings(t *testing.T) { } } -func TestResolveRoute_PeerBinding(t *testing.T) { - agents := []config.AgentConfig{ - {ID: "sales", Default: true}, - {ID: "support"}, - } - bindings := []config.AgentBinding{ - { - AgentID: "support", - Match: config.BindingMatch{ - Channel: "telegram", - AccountID: "*", - Peer: &config.PeerMatch{Kind: "direct", ID: "user123"}, - }, - }, - } - cfg := testConfig(agents, bindings) +func TestResolveRoute_UsesNormalizedInboundContextFields(t *testing.T) { + cfg := testConfig([]config.AgentConfig{{ID: "sales", Default: true}}) r := NewRouteResolver(cfg) route := r.ResolveRoute(bus.InboundContext{ - Channel: "telegram", + Channel: "Telegram", + Account: "Bot2", ChatType: "direct", SenderID: "user123", }) - if route.AgentID != "support" { - t.Errorf("AgentID = %q, want 'support'", route.AgentID) + if route.AgentID != "sales" { + t.Errorf("AgentID = %q, want 'sales'", route.AgentID) } - if route.MatchedBy != "binding.peer" { - t.Errorf("MatchedBy = %q, want 'binding.peer'", route.MatchedBy) + if route.Channel != "telegram" { + t.Errorf("Channel = %q, want 'telegram'", route.Channel) } -} - -func TestResolveRoute_GuildBinding(t *testing.T) { - agents := []config.AgentConfig{ - {ID: "general", Default: true}, - {ID: "gaming"}, + if route.AccountID != "bot2" { + t.Errorf("AccountID = %q, want 'bot2'", route.AccountID) } - bindings := []config.AgentBinding{ - { - AgentID: "gaming", - Match: config.BindingMatch{ - Channel: "discord", - AccountID: "*", - GuildID: "guild-abc", - }, - }, - } - cfg := testConfig(agents, bindings) - r := NewRouteResolver(cfg) - - route := r.ResolveRoute(bus.InboundContext{ - Channel: "discord", - ChatID: "ch1", - ChatType: "channel", - SpaceID: "guild-abc", - SpaceType: "guild", - }) - - if route.AgentID != "gaming" { - t.Errorf("AgentID = %q, want 'gaming'", route.AgentID) - } - if route.MatchedBy != "binding.guild" { - t.Errorf("MatchedBy = %q, want 'binding.guild'", route.MatchedBy) - } -} - -func TestResolveRoute_TeamBinding(t *testing.T) { - agents := []config.AgentConfig{ - {ID: "general", Default: true}, - {ID: "work"}, - } - bindings := []config.AgentBinding{ - { - AgentID: "work", - Match: config.BindingMatch{ - Channel: "slack", - AccountID: "*", - TeamID: "T12345", - }, - }, - } - cfg := testConfig(agents, bindings) - r := NewRouteResolver(cfg) - - route := r.ResolveRoute(bus.InboundContext{ - Channel: "slack", - ChatID: "C001", - ChatType: "channel", - SpaceID: "T12345", - SpaceType: "team", - }) - - if route.AgentID != "work" { - t.Errorf("AgentID = %q, want 'work'", route.AgentID) - } - if route.MatchedBy != "binding.team" { - t.Errorf("MatchedBy = %q, want 'binding.team'", route.MatchedBy) - } -} - -func TestResolveRoute_AccountBinding(t *testing.T) { - agents := []config.AgentConfig{ - {ID: "default-agent", Default: true}, - {ID: "premium"}, - } - bindings := []config.AgentBinding{ - { - AgentID: "premium", - Match: config.BindingMatch{ - Channel: "telegram", - AccountID: "bot2", - }, - }, - } - cfg := testConfig(agents, bindings) - r := NewRouteResolver(cfg) - - route := r.ResolveRoute(bus.InboundContext{ - Channel: "telegram", - Account: "bot2", - ChatType: "direct", - SenderID: "user1", - }) - - if route.AgentID != "premium" { - t.Errorf("AgentID = %q, want 'premium'", route.AgentID) - } - if route.MatchedBy != "binding.account" { - t.Errorf("MatchedBy = %q, want 'binding.account'", route.MatchedBy) - } -} - -func TestResolveRoute_ChannelWildcard(t *testing.T) { - agents := []config.AgentConfig{ - {ID: "main", Default: true}, - {ID: "telegram-bot"}, - } - bindings := []config.AgentBinding{ - { - AgentID: "telegram-bot", - Match: config.BindingMatch{ - Channel: "telegram", - AccountID: "*", - }, - }, - } - cfg := testConfig(agents, bindings) - r := NewRouteResolver(cfg) - - route := r.ResolveRoute(bus.InboundContext{ - Channel: "telegram", - ChatType: "direct", - SenderID: "user1", - }) - - if route.AgentID != "telegram-bot" { - t.Errorf("AgentID = %q, want 'telegram-bot'", route.AgentID) - } - if route.MatchedBy != "binding.channel" { - t.Errorf("MatchedBy = %q, want 'binding.channel'", route.MatchedBy) - } -} - -func TestResolveRoute_PriorityOrder_PeerBeatsGuild(t *testing.T) { - agents := []config.AgentConfig{ - {ID: "general", Default: true}, - {ID: "vip"}, - {ID: "gaming"}, - } - bindings := []config.AgentBinding{ - { - AgentID: "vip", - Match: config.BindingMatch{ - Channel: "discord", - AccountID: "*", - Peer: &config.PeerMatch{Kind: "direct", ID: "user-vip"}, - }, - }, - { - AgentID: "gaming", - Match: config.BindingMatch{ - Channel: "discord", - AccountID: "*", - GuildID: "guild-1", - }, - }, - } - cfg := testConfig(agents, bindings) - r := NewRouteResolver(cfg) - - route := r.ResolveRoute(bus.InboundContext{ - Channel: "discord", - ChatType: "direct", - SenderID: "user-vip", - SpaceID: "guild-1", - SpaceType: "guild", - }) - - if route.AgentID != "vip" { - t.Errorf("AgentID = %q, want 'vip' (peer should beat guild)", route.AgentID) - } - if route.MatchedBy != "binding.peer" { - t.Errorf("MatchedBy = %q, want 'binding.peer'", route.MatchedBy) + if route.MatchedBy != "default" { + t.Errorf("MatchedBy = %q, want 'default'", route.MatchedBy) } } @@ -257,16 +75,7 @@ func TestResolveRoute_InvalidAgentFallsToDefault(t *testing.T) { agents := []config.AgentConfig{ {ID: "main", Default: true}, } - bindings := []config.AgentBinding{ - { - AgentID: "nonexistent", - Match: config.BindingMatch{ - Channel: "telegram", - AccountID: "*", - }, - }, - } - cfg := testConfig(agents, bindings) + cfg := testConfig(agents) r := NewRouteResolver(cfg) route := r.ResolveRoute(bus.InboundContext{Channel: "telegram"}) @@ -282,7 +91,7 @@ func TestResolveRoute_DefaultAgentSelection(t *testing.T) { {ID: "beta", Default: true}, {ID: "gamma"}, } - cfg := testConfig(agents, nil) + cfg := testConfig(agents) r := NewRouteResolver(cfg) route := r.ResolveRoute(bus.InboundContext{Channel: "cli"}) @@ -297,7 +106,7 @@ func TestResolveRoute_NoDefaultUsesFirst(t *testing.T) { {ID: "alpha"}, {ID: "beta"}, } - cfg := testConfig(agents, nil) + cfg := testConfig(agents) r := NewRouteResolver(cfg) route := r.ResolveRoute(bus.InboundContext{Channel: "cli"}) From 82bfe0d9a0cc98990c159a71f2b10fc857326acb Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 21:34:49 +0800 Subject: [PATCH 016/174] docs(config): remove legacy bindings guide --- docs/configuration.md | 130 ++---------------------------------------- 1 file changed, 6 insertions(+), 124 deletions(-) diff --git a/docs/configuration.md b/docs/configuration.md index 58930cbfa..52410b823 100644 --- a/docs/configuration.md +++ b/docs/configuration.md @@ -120,133 +120,15 @@ dammi le ultime news - Unknown slash command (for example `/foo`) passes through to normal LLM processing. - Registered but unsupported command on the current channel (for example `/show` on WhatsApp) returns an explicit user-facing error and stops further processing. -### Agent Bindings (Route messages to specific agents) +### Routing -Use `bindings` in `config.json` to route incoming messages to different agents by channel/account/context. +The legacy `bindings` configuration has been removed from `config.json`. -```json -{ - "agents": { - "defaults": { - "workspace": "~/.picoclaw/workspace", - "model_name": "gpt-4o-mini" - }, - "list": [ - { "id": "main", "default": true, "name": "Main Assistant" }, - { "id": "support", "name": "Support Assistant" }, - { "id": "sales", "name": "Sales Assistant" } - ] - }, - "bindings": [ - { - "agent_id": "support", - "match": { - "channel": "telegram", - "account_id": "*", - "peer": { "kind": "direct", "id": "user123" } - } - }, - { - "agent_id": "sales", - "match": { - "channel": "discord", - "account_id": "my-discord-bot", - "guild_id": "987654321" - } - } - ] -} -``` +Current routing always resolves to the configured default agent. Session +segmentation remains configurable through `session.dimensions`. -#### `bindings` fields - -| Field | Required | Description | -|-------|----------|-------------| -| `agent_id` | Yes | Target agent id in `agents.list` | -| `match.channel` | Yes | Channel name (e.g. `telegram`, `discord`) | -| `match.account_id` | No | Channel account filter. Use `"*"` for all accounts of that channel. If omitted, only default account is matched | -| `match.peer.kind` + `match.peer.id` | No | Exact peer match (e.g. direct chat / topic / group id) | -| `match.guild_id` | No | Guild/server-level match | -| `match.team_id` | No | Team/workspace-level match | - -#### Matching priority - -When multiple bindings exist, PicoClaw resolves in this order: - -1. `peer` -2. `parent_peer` (for thread/topic parent contexts) -3. `guild_id` -4. `team_id` -5. `account_id` (non-wildcard) -6. channel wildcard (`account_id: "*"`) -7. default agent - -If a binding points to a missing `agent_id`, PicoClaw falls back to the default agent. - -#### How matching works (step-by-step) - -1. PicoClaw first filters bindings by `match.channel` (must equal current channel). -2. It then filters by `match.account_id`: - - omitted: match only the channel's default account - - `"*"`: match all accounts on this channel - - explicit value: exact account id match (case-insensitive) -3. From the remaining candidates, it applies the priority chain above and stops at the first hit. - -In other words: **channel + account form the candidate set; peer/guild/team then decide final winner**. - -#### Common recipes - -**1) Route one specific DM user to a specialist agent** - -```json -{ - "agent_id": "support", - "match": { - "channel": "telegram", - "account_id": "*", - "peer": { "kind": "direct", "id": "user123" } - } -} -``` - -**2) Route one Discord server (guild) to a dedicated agent** - -```json -{ - "agent_id": "sales", - "match": { - "channel": "discord", - "account_id": "my-discord-bot", - "guild_id": "987654321" - } -} -``` - -**3) Route all remaining traffic of a channel to a fallback agent** - -```json -{ - "agent_id": "main", - "match": { - "channel": "discord", - "account_id": "*" - } -} -``` - -#### Authoring guidelines (important) - -- Keep exactly one clear default agent in `agents.list` (`"default": true`). -- Put specific rules (`peer`, `guild_id`, `team_id`) and broad rules (`account_id: "*"` only) together safely; priority already guarantees specific rules win. -- Avoid duplicate rules with the same specificity and match values. If duplicates exist, the first matching entry in the config array wins. -- Ensure every `agent_id` exists in `agents.list`; unknown IDs silently fall back to default. - -#### Troubleshooting checklist - -- **Rule not taking effect?** Check `match.channel` spelling first (must be exact). -- **Expected account-specific routing but still using default?** Verify `match.account_id` equals actual runtime account id. -- **Wildcard catches too much traffic?** Add more specific `peer/guild/team` rules for critical paths. -- **Unexpected default fallback?** Confirm `agent_id` exists and is not misspelled. +The next-generation binding and routing system will be introduced through a new +schema rather than extending the removed `bindings` format. ### 🔒 Security Sandbox From bef17d6453425ab7beee61f3a5ead88b15aa85e6 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 22:13:04 +0800 Subject: [PATCH 017/174] feat(routing): add ordered dispatch rules --- docs/configuration.md | 73 ++++++++++++++- pkg/agent/loop_test.go | 80 ++++++++++++++-- pkg/config/config.go | 26 +++++- pkg/config/config_test.go | 71 +++++++++++--- pkg/routing/route.go | 189 +++++++++++++++++++++++++++++++++++++- pkg/routing/route_test.go | 116 +++++++++++++++++++++++ 6 files changed, 524 insertions(+), 31 deletions(-) diff --git a/docs/configuration.md b/docs/configuration.md index 52410b823..363b59690 100644 --- a/docs/configuration.md +++ b/docs/configuration.md @@ -122,13 +122,76 @@ dammi le ultime news ### Routing -The legacy `bindings` configuration has been removed from `config.json`. +Routing is configured through `agents.dispatch.rules`. -Current routing always resolves to the configured default agent. Session -segmentation remains configurable through `session.dimensions`. +Each rule matches against the normalized inbound context produced by channels. +Rules are evaluated from top to bottom. The first matching rule wins. If no +rule matches, PicoClaw falls back to the configured default agent. -The next-generation binding and routing system will be introduced through a new -schema rather than extending the removed `bindings` format. +Supported match fields: + +* `channel` +* `account` +* `space` +* `chat` +* `topic` +* `sender` +* `mentioned` + +Match values use the same scope vocabulary as the session system: + +* `space`: `workspace:t001`, `guild:123456` +* `chat`: `direct:user123`, `group:-100123`, `channel:c123` +* `topic`: `topic:42` +* `sender`: a normalized sender identifier for the platform + +Rules may optionally override the global `session.dimensions` value through +`session_dimensions`. This allows routing and session allocation to stay aligned +without reintroducing the old `bindings` or `dm_scope` formats. + +Example: + +```json +{ + "agents": { + "list": [ + { "id": "main", "default": true }, + { "id": "support" }, + { "id": "sales" } + ], + "dispatch": { + "rules": [ + { + "name": "vip in support group", + "agent": "sales", + "when": { + "channel": "telegram", + "chat": "group:-1001234567890", + "sender": "12345" + }, + "session_dimensions": ["chat", "sender"] + }, + { + "name": "telegram support group", + "agent": "support", + "when": { + "channel": "telegram", + "chat": "group:-1001234567890" + }, + "session_dimensions": ["chat"] + } + ] + } + }, + "session": { + "dimensions": ["chat"] + } +} +``` + +In the example above, the VIP rule must appear before the broader group rule. +Because routing is strictly ordered, more specific rules should be placed +earlier and broader fallback rules later. ### 🔒 Security Sandbox diff --git a/pkg/agent/loop_test.go b/pkg/agent/loop_test.go index f288f1f2b..6d6ee4a6d 100644 --- a/pkg/agent/loop_test.go +++ b/pkg/agent/loop_test.go @@ -755,12 +755,12 @@ func TestAppendEventContextFields_IncludesInboundRouteAndScope(t *testing.T) { SenderID: "U123", Mentioned: true, }, - Route: &routing.ResolvedRoute{ - AgentID: "support", - Channel: "slack", - AccountID: "workspace-a", - MatchedBy: "default", - SessionPolicy: routing.SessionPolicy{ + Route: &routing.ResolvedRoute{ + AgentID: "support", + Channel: "slack", + AccountID: "workspace-a", + MatchedBy: "default", + SessionPolicy: routing.SessionPolicy{ Dimensions: []string{"chat", "sender"}, IdentityLinks: map[string][]string{ "canonical-user": {"slack:U123"}, @@ -853,6 +853,74 @@ func TestResolveMessageRoute_UsesInboundContextAccount(t *testing.T) { } } +func TestResolveMessageRoute_UsesDispatchRulesInOrder(t *testing.T) { + tmpDir := t.TempDir() + cfg := &config.Config{ + Agents: config.AgentsConfig{ + Defaults: config.AgentDefaults{ + Workspace: tmpDir, + ModelName: "test-model", + }, + List: []config.AgentConfig{ + {ID: "main", Default: true}, + {ID: "support"}, + {ID: "sales"}, + }, + Dispatch: &config.DispatchConfig{ + Rules: []config.DispatchRule{ + { + Name: "support-group", + Agent: "support", + When: config.DispatchSelector{ + Channel: "telegram", + Chat: "group:-100123", + }, + SessionDimensions: []string{"chat"}, + }, + { + Name: "vip-in-group", + Agent: "sales", + When: config.DispatchSelector{ + Channel: "telegram", + Chat: "group:-100123", + Sender: "12345", + }, + SessionDimensions: []string{"chat", "sender"}, + }, + }, + }, + }, + Session: config.SessionConfig{ + Dimensions: []string{"sender"}, + }, + } + + msgBus := bus.NewMessageBus() + al := NewAgentLoop(cfg, msgBus, &simpleMockProvider{response: "ok"}) + + route, _, err := al.resolveMessageRoute(testInboundMessage(bus.InboundMessage{ + Context: bus.InboundContext{ + Channel: "telegram", + ChatID: "-100123", + ChatType: "group", + SenderID: "12345", + }, + Content: "hello", + })) + if err != nil { + t.Fatalf("resolveMessageRoute() error = %v", err) + } + if route.AgentID != "support" { + t.Fatalf("AgentID = %q, want support", route.AgentID) + } + if route.MatchedBy != "dispatch.rule:support-group" { + t.Fatalf("MatchedBy = %q, want dispatch.rule:support-group", route.MatchedBy) + } + if got := route.SessionPolicy.Dimensions; len(got) != 1 || got[0] != "chat" { + t.Fatalf("SessionPolicy.Dimensions = %v, want [chat]", got) + } +} + func TestProcessMessage_MediaArtifactCanBeForwardedBySendFile(t *testing.T) { tmpDir := t.TempDir() cfg := config.DefaultConfig() diff --git a/pkg/config/config.go b/pkg/config/config.go index 739980912..23ba57086 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -117,8 +117,9 @@ func (c *Config) MarshalJSON() ([]byte, error) { } type AgentsConfig struct { - Defaults AgentDefaults `json:"defaults"` - List []AgentConfig `json:"list,omitempty"` + Defaults AgentDefaults `json:"defaults"` + List []AgentConfig `json:"list,omitempty"` + Dispatch *DispatchConfig `json:"dispatch,omitempty"` } // AgentModelConfig supports both string and structured model config. @@ -175,6 +176,27 @@ type SubagentsConfig struct { Model *AgentModelConfig `json:"model,omitempty"` } +type DispatchConfig struct { + Rules []DispatchRule `json:"rules,omitempty"` +} + +type DispatchRule struct { + Name string `json:"name,omitempty"` + Agent string `json:"agent"` + When DispatchSelector `json:"when"` + SessionDimensions []string `json:"session_dimensions,omitempty"` +} + +type DispatchSelector struct { + Channel string `json:"channel,omitempty"` + Account string `json:"account,omitempty"` + Space string `json:"space,omitempty"` + Chat string `json:"chat,omitempty"` + Topic string `json:"topic,omitempty"` + Sender string `json:"sender,omitempty"` + Mentioned *bool `json:"mentioned,omitempty"` +} + type SessionConfig struct { Dimensions []string `json:"dimensions,omitempty"` IdentityLinks map[string][]string `json:"identity_links,omitempty"` diff --git a/pkg/config/config_test.go b/pkg/config/config_test.go index 58c1461f5..41c498d91 100644 --- a/pkg/config/config_test.go +++ b/pkg/config/config_test.go @@ -126,16 +126,6 @@ func TestAgentConfig_FullParse(t *testing.T) { } ] }, - "bindings": [ - { - "agent_id": "support", - "match": { - "channel": "telegram", - "account_id": "*", - "peer": {"kind": "direct", "id": "user123"} - } - } - ], "session": { "dimensions": ["sender"], "identity_links": { @@ -175,9 +165,9 @@ func TestAgentConfig_FullParse(t *testing.T) { t.Errorf("support.Subagents = %+v", support.Subagents) } - if len(cfg.Session.Dimensions) != 1 || cfg.Session.Dimensions[0] != "sender" { - t.Errorf("Session.Dimensions = %v", cfg.Session.Dimensions) - } + if len(cfg.Session.Dimensions) != 1 || cfg.Session.Dimensions[0] != "sender" { + t.Errorf("Session.Dimensions = %v", cfg.Session.Dimensions) + } if len(cfg.Session.IdentityLinks) != 1 { t.Errorf("Session.IdentityLinks = %v", cfg.Session.IdentityLinks) } @@ -209,6 +199,60 @@ func TestConfig_BackwardCompat_NoAgentsList(t *testing.T) { } } +func TestAgentConfig_ParsesDispatchRules(t *testing.T) { + jsonData := `{ + "agents": { + "defaults": { + "workspace": "~/.picoclaw/workspace", + "model": "glm-4.7" + }, + "list": [ + { "id": "main", "default": true }, + { "id": "support" } + ], + "dispatch": { + "rules": [ + { + "name": "support-vip", + "agent": "support", + "when": { + "channel": "telegram", + "chat": "group:-100123", + "sender": "12345", + "mentioned": true + }, + "session_dimensions": ["chat", "sender"] + } + ] + } + } + }` + + cfg := DefaultConfig() + if err := json.Unmarshal([]byte(jsonData), cfg); err != nil { + t.Fatalf("unmarshal: %v", err) + } + if cfg.Agents.Dispatch == nil { + t.Fatal("Agents.Dispatch should not be nil") + } + if len(cfg.Agents.Dispatch.Rules) != 1 { + t.Fatalf("Dispatch.Rules len = %d, want 1", len(cfg.Agents.Dispatch.Rules)) + } + rule := cfg.Agents.Dispatch.Rules[0] + if rule.Name != "support-vip" || rule.Agent != "support" { + t.Fatalf("rule = %+v", rule) + } + if rule.When.Channel != "telegram" || rule.When.Chat != "group:-100123" || rule.When.Sender != "12345" { + t.Fatalf("rule.When = %+v", rule.When) + } + if rule.When.Mentioned == nil || !*rule.When.Mentioned { + t.Fatalf("rule.When.Mentioned = %+v, want true", rule.When.Mentioned) + } + if got := rule.SessionDimensions; len(got) != 2 || got[0] != "chat" || got[1] != "sender" { + t.Fatalf("rule.SessionDimensions = %v, want [chat sender]", got) + } +} + // TestDefaultConfig_HeartbeatEnabled verifies heartbeat is enabled by default func TestDefaultConfig_HeartbeatEnabled(t *testing.T) { cfg := DefaultConfig() @@ -964,7 +1008,6 @@ func TestLoadConfig_TelegramPlaceholderTextAcceptsSingleString(t *testing.T) { data := `{ "version": 1, "agents": { "defaults": { "workspace": "", "model": "", "max_tokens": 0, "max_tool_iterations": 0 } }, - "bindings": [], "session": {}, "channels": { "telegram": { diff --git a/pkg/routing/route.go b/pkg/routing/route.go index 6300460f8..023f35a25 100644 --- a/pkg/routing/route.go +++ b/pkg/routing/route.go @@ -1,6 +1,7 @@ package routing import ( + "fmt" "strings" "github.com/sipeed/picoclaw/pkg/bus" @@ -19,7 +20,7 @@ type ResolvedRoute struct { Channel string AccountID string SessionPolicy SessionPolicy - MatchedBy string // currently always "default" until the new binding system lands + MatchedBy string } // RouteResolver determines which agent handles a message. @@ -38,12 +39,24 @@ func NewRouteResolver(cfg *config.Config) *RouteResolver { func (r *RouteResolver) ResolveRoute(inbound bus.InboundContext) ResolvedRoute { channel := strings.ToLower(strings.TrimSpace(inbound.Channel)) accountID := NormalizeAccountID(inbound.Account) + identityLinks := cloneIdentityLinks(r.cfg.Session.IdentityLinks) + view := buildDispatchView(inbound, identityLinks) + + if rule := r.matchDispatchRule(view); rule != nil { + return ResolvedRoute{ + AgentID: r.pickAgentID(rule.Agent), + Channel: channel, + AccountID: accountID, + SessionPolicy: r.sessionPolicy(rule), + MatchedBy: matchedByForRule(rule), + } + } return ResolvedRoute{ AgentID: r.pickAgentID(r.resolveDefaultAgentID()), Channel: channel, AccountID: accountID, - SessionPolicy: r.sessionPolicy(), + SessionPolicy: r.sessionPolicy(nil), MatchedBy: "default", } } @@ -85,9 +98,13 @@ func (r *RouteResolver) resolveDefaultAgentID() string { return DefaultAgentID } -func (r *RouteResolver) sessionPolicy() SessionPolicy { +func (r *RouteResolver) sessionPolicy(rule *config.DispatchRule) SessionPolicy { + dimensions := r.cfg.Session.Dimensions + if rule != nil && len(rule.SessionDimensions) > 0 { + dimensions = rule.SessionDimensions + } return SessionPolicy{ - Dimensions: normalizeSessionDimensions(r.cfg.Session.Dimensions), + Dimensions: normalizeSessionDimensions(dimensions), IdentityLinks: cloneIdentityLinks(r.cfg.Session.IdentityLinks), } } @@ -130,3 +147,167 @@ func cloneIdentityLinks(src map[string][]string) map[string][]string { } return cloned } + +type dispatchView struct { + Channel string + Account string + Space string + Chat string + Topic string + Sender string + Mentioned bool +} + +func (r *RouteResolver) matchDispatchRule(view dispatchView) *config.DispatchRule { + if r.cfg == nil || r.cfg.Agents.Dispatch == nil || len(r.cfg.Agents.Dispatch.Rules) == 0 { + return nil + } + + for i := range r.cfg.Agents.Dispatch.Rules { + rule := &r.cfg.Agents.Dispatch.Rules[i] + if !selectorHasAnyConstraint(rule.When) { + continue + } + if ruleMatchesView(*rule, view) { + return rule + } + } + return nil +} + +func ruleMatchesView(rule config.DispatchRule, view dispatchView) bool { + when := normalizeDispatchSelector(rule.When) + if when.Channel != "" && when.Channel != view.Channel { + return false + } + if when.Account != "" && when.Account != view.Account { + return false + } + if when.Space != "" && when.Space != view.Space { + return false + } + if when.Chat != "" && when.Chat != view.Chat { + return false + } + if when.Topic != "" && when.Topic != view.Topic { + return false + } + if when.Sender != "" && when.Sender != view.Sender { + return false + } + if when.Mentioned != nil && *when.Mentioned != view.Mentioned { + return false + } + return true +} + +func matchedByForRule(rule *config.DispatchRule) string { + if rule == nil { + return "default" + } + name := strings.TrimSpace(rule.Name) + if name == "" { + return "dispatch.rule" + } + return "dispatch.rule:" + strings.ToLower(name) +} + +func buildDispatchView(inbound bus.InboundContext, identityLinks map[string][]string) dispatchView { + view := dispatchView{ + Channel: strings.ToLower(strings.TrimSpace(inbound.Channel)), + Account: NormalizeAccountID(inbound.Account), + Mentioned: inbound.Mentioned, + } + + if spaceID := strings.TrimSpace(inbound.SpaceID); spaceID != "" { + spaceType := strings.ToLower(strings.TrimSpace(inbound.SpaceType)) + if spaceType == "" { + spaceType = "space" + } + view.Space = fmt.Sprintf("%s:%s", spaceType, strings.ToLower(spaceID)) + } + + if chatID := strings.TrimSpace(inbound.ChatID); chatID != "" { + chatType := strings.ToLower(strings.TrimSpace(inbound.ChatType)) + if chatType == "" { + chatType = "direct" + } + view.Chat = fmt.Sprintf("%s:%s", chatType, strings.ToLower(chatID)) + } + + if topicID := strings.TrimSpace(inbound.TopicID); topicID != "" { + view.Topic = "topic:" + strings.ToLower(topicID) + } + + view.Sender = canonicalDispatchSenderID(inbound.Channel, inbound.SenderID, identityLinks) + + return view +} + +func normalizeDispatchSelector(selector config.DispatchSelector) config.DispatchSelector { + selector.Channel = strings.ToLower(strings.TrimSpace(selector.Channel)) + selector.Account = NormalizeAccountID(selector.Account) + selector.Space = strings.ToLower(strings.TrimSpace(selector.Space)) + selector.Chat = strings.ToLower(strings.TrimSpace(selector.Chat)) + selector.Topic = strings.ToLower(strings.TrimSpace(selector.Topic)) + selector.Sender = strings.ToLower(strings.TrimSpace(selector.Sender)) + return selector +} + +func selectorHasAnyConstraint(selector config.DispatchSelector) bool { + return strings.TrimSpace(selector.Channel) != "" || + strings.TrimSpace(selector.Account) != "" || + strings.TrimSpace(selector.Space) != "" || + strings.TrimSpace(selector.Chat) != "" || + strings.TrimSpace(selector.Topic) != "" || + strings.TrimSpace(selector.Sender) != "" || + selector.Mentioned != nil +} + +func canonicalDispatchSenderID(channel, rawID string, identityLinks map[string][]string) string { + normalizedID := strings.TrimSpace(rawID) + if normalizedID == "" { + return "" + } + if linked := resolveLinkedDispatchID(identityLinks, channel, normalizedID); linked != "" { + normalizedID = linked + } + return strings.ToLower(normalizedID) +} + +func resolveLinkedDispatchID(identityLinks map[string][]string, channel, peerID string) string { + if len(identityLinks) == 0 { + return "" + } + peerID = strings.TrimSpace(peerID) + if peerID == "" { + return "" + } + + candidates := make(map[string]bool) + rawCandidate := strings.ToLower(peerID) + if rawCandidate != "" { + candidates[rawCandidate] = true + } + channel = strings.ToLower(strings.TrimSpace(channel)) + if channel != "" { + candidates[fmt.Sprintf("%s:%s", channel, rawCandidate)] = true + } + if idx := strings.Index(rawCandidate, ":"); idx > 0 && idx < len(rawCandidate)-1 { + candidates[rawCandidate[idx+1:]] = true + } + + for canonical, ids := range identityLinks { + canonicalName := strings.TrimSpace(canonical) + if canonicalName == "" { + continue + } + for _, id := range ids { + normalized := strings.ToLower(strings.TrimSpace(id)) + if normalized != "" && candidates[normalized] { + return canonicalName + } + } + } + return "" +} diff --git a/pkg/routing/route_test.go b/pkg/routing/route_test.go index b4e3d6406..729e880fe 100644 --- a/pkg/routing/route_test.go +++ b/pkg/routing/route_test.go @@ -71,6 +71,122 @@ func TestResolveRoute_UsesNormalizedInboundContextFields(t *testing.T) { } } +func TestResolveRoute_DispatchFirstMatchWins(t *testing.T) { + cfg := testConfig([]config.AgentConfig{ + {ID: "main", Default: true}, + {ID: "support"}, + {ID: "sales"}, + }) + cfg.Agents.Dispatch = &config.DispatchConfig{ + Rules: []config.DispatchRule{ + { + Name: "support-group", + Agent: "support", + When: config.DispatchSelector{ + Channel: "telegram", + Chat: "group:-100123", + }, + }, + { + Name: "vip-in-group", + Agent: "sales", + When: config.DispatchSelector{ + Channel: "telegram", + Chat: "group:-100123", + Sender: "12345", + }, + }, + }, + } + r := NewRouteResolver(cfg) + + route := r.ResolveRoute(bus.InboundContext{ + Channel: "telegram", + ChatID: "-100123", + ChatType: "group", + SenderID: "12345", + }) + + if route.AgentID != "support" { + t.Fatalf("AgentID = %q, want support", route.AgentID) + } + if route.MatchedBy != "dispatch.rule:support-group" { + t.Fatalf("MatchedBy = %q, want dispatch.rule:support-group", route.MatchedBy) + } +} + +func TestResolveRoute_DispatchOverridesSessionDimensions(t *testing.T) { + cfg := testConfig([]config.AgentConfig{ + {ID: "main", Default: true}, + {ID: "support"}, + }) + cfg.Session.Dimensions = []string{"chat"} + cfg.Agents.Dispatch = &config.DispatchConfig{ + Rules: []config.DispatchRule{ + { + Name: "support-dm", + Agent: "support", + When: config.DispatchSelector{ + Channel: "telegram", + Chat: "direct:user-1", + }, + SessionDimensions: []string{"chat", "sender"}, + }, + }, + } + r := NewRouteResolver(cfg) + + route := r.ResolveRoute(bus.InboundContext{ + Channel: "telegram", + ChatID: "user-1", + ChatType: "direct", + SenderID: "user-1", + }) + + if route.AgentID != "support" { + t.Fatalf("AgentID = %q, want support", route.AgentID) + } + if got := route.SessionPolicy.Dimensions; len(got) != 2 || got[0] != "chat" || got[1] != "sender" { + t.Fatalf("SessionPolicy.Dimensions = %v, want [chat sender]", got) + } +} + +func TestResolveRoute_DispatchMentionedRule(t *testing.T) { + cfg := testConfig([]config.AgentConfig{ + {ID: "main", Default: true}, + {ID: "support"}, + }) + mentioned := true + cfg.Agents.Dispatch = &config.DispatchConfig{ + Rules: []config.DispatchRule{ + { + Name: "slack-mentions", + Agent: "support", + When: config.DispatchSelector{ + Channel: "slack", + Space: "workspace:t001", + Mentioned: &mentioned, + }, + }, + }, + } + r := NewRouteResolver(cfg) + + route := r.ResolveRoute(bus.InboundContext{ + Channel: "slack", + ChatID: "C123", + ChatType: "channel", + SpaceID: "T001", + SpaceType: "workspace", + SenderID: "U123", + Mentioned: true, + }) + + if route.AgentID != "support" { + t.Fatalf("AgentID = %q, want support", route.AgentID) + } +} + func TestResolveRoute_InvalidAgentFallsToDefault(t *testing.T) { agents := []config.AgentConfig{ {ID: "main", Default: true}, From 168b75ae214314307d1f49809747a6f05e3390c4 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Wed, 1 Apr 2026 22:51:28 +0800 Subject: [PATCH 018/174] style(lint): fix config and qq formatting --- pkg/channels/qq/qq_test.go | 16 ++++++++-------- pkg/config/config.go | 24 +++++++++++++----------- 2 files changed, 21 insertions(+), 19 deletions(-) diff --git a/pkg/channels/qq/qq_test.go b/pkg/channels/qq/qq_test.go index 905532f01..a34aac9ca 100644 --- a/pkg/channels/qq/qq_test.go +++ b/pkg/channels/qq/qq_test.go @@ -50,15 +50,15 @@ func TestHandleC2CMessage_IncludesAccountIDMetadata(t *testing.T) { case <-ctx.Done(): t.Fatal("timeout waiting for inbound message") return - case inbound, ok := <-messageBus.InboundChan(): - if !ok { - t.Fatal("expected inbound message") - } - if inbound.Context.Raw["account_id"] != "7750283E123456" { - t.Fatalf("account_id raw = %q, want %q", inbound.Context.Raw["account_id"], "7750283E123456") - } - return + case inbound, ok := <-messageBus.InboundChan(): + if !ok { + t.Fatal("expected inbound message") } + if inbound.Context.Raw["account_id"] != "7750283E123456" { + t.Fatalf("account_id raw = %q, want %q", inbound.Context.Raw["account_id"], "7750283E123456") + } + return + } } } diff --git a/pkg/config/config.go b/pkg/config/config.go index 23ba57086..99072e2ff 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -25,17 +25,19 @@ const CurrentVersion = 2 // Config is the current config structure with version support type Config struct { - Version int `json:"version" yaml:"-"` // Config schema version for migration - Agents AgentsConfig `json:"agents" yaml:"-"` - Session SessionConfig `json:"session,omitempty" yaml:"-"` - Channels ChannelsConfig `json:"channels" yaml:"channels"` - ModelList SecureModelList `json:"model_list" yaml:"model_list"` // New model-centric provider configuration - Gateway GatewayConfig `json:"gateway" yaml:"-"` - Hooks HooksConfig `json:"hooks,omitempty" yaml:"-"` - Tools ToolsConfig `json:"tools" yaml:",inline"` - Heartbeat HeartbeatConfig `json:"heartbeat" yaml:"-"` - Devices DevicesConfig `json:"devices" yaml:"-"` - Voice VoiceConfig `json:"voice" yaml:"-"` + // Config schema version for migration. + Version int `json:"version" yaml:"-"` + Agents AgentsConfig `json:"agents" yaml:"-"` + Session SessionConfig `json:"session,omitempty" yaml:"-"` + Channels ChannelsConfig `json:"channels" yaml:"channels"` + // New model-centric provider configuration. + ModelList SecureModelList `json:"model_list" yaml:"model_list"` + Gateway GatewayConfig `json:"gateway" yaml:"-"` + Hooks HooksConfig `json:"hooks,omitempty" yaml:"-"` + Tools ToolsConfig `json:"tools" yaml:",inline"` + Heartbeat HeartbeatConfig `json:"heartbeat" yaml:"-"` + Devices DevicesConfig `json:"devices" yaml:"-"` + Voice VoiceConfig `json:"voice" yaml:"-"` // BuildInfo contains build-time version information BuildInfo BuildInfo `json:"build_info,omitempty" yaml:"-"` From 15a70ac45c5a37ddeeede8150431e5b6e1de6516 Mon Sep 17 00:00:00 2001 From: Liu Yuan Date: Sun, 5 Apr 2026 09:05:16 +0800 Subject: [PATCH 019/174] feat(seahorse): implement short-term memory engine (LCM) (#2285) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat(seahorse): implement short-term memory engine of seahorse Add pkg/seahorse/ module implementing a SQLite-backed DAG-based summary hierarchy for context management, ported from lossless-claw's LCM design: - types.go + short_constants.go: core types (Message, Summary, Conversation, ContextItem) and configuration constants (fanout, token targets, thresholds) - migration.go: idempotent DB schema with FTS5 trigram tokenizer for CJK - store.go: full SQLite CRUD (conversations, messages, summaries DAG, context_items with ordinal gap numbering, FTS5 search) - short_engine.go: Engine lifecycle (NewEngine, Ingest, Assemble, Compact), session pattern filtering (ignore/stateless glob→regex compilation), per-session mutex via sync.Map - short_assembler.go: budget-aware context assembly with fresh tail protection (32 messages), oldest-first eviction, summary XML formatting, RebuildContextItems - short_compaction.go: leaf compaction (messages→summary) and condensed compaction (summaries→higher-level summary), 3-level LLM escalation, CompactUntilUnder for emergency overflow - short_retrieval.go: lookupByID, FTS5/LIKE search, recursive expand with token cap - context_seahorse.go: agent.ContextManager adapter, registered as "seahorse", provider↔seahorse message type conversion (ToolCalls, tool_result) * fix(seahorse): correct 3 adapter bugs in context management - TokenCount: use full message (Content+ToolCalls+Media) instead of Content-only - Empty Content: rebuild Content from tool_result Parts when stored empty - Duplicate summaries: summaries only in Summary field, not in History messages - Grep: fix SearchResult.Snippet→Content for summaries - Schema: fix FTS5 SQL uses VIRTUAL TABLE not TEMP TABLE - TestFTS5SQLConstants: verify FTS5 SQL syntax correctness - Test: fix flaky TestCompactLeaf * fix(agent): ingest steering messages into seahorse SQLite Steering messages were only persisted to session JSONL but not ingested into seahorse SQLite, causing them to be missing from context assembly. Added `ts.ingestMessage(turnCtx, al, pm)` call in the steering message injection block alongside the existing JSONL persistence. Test: TestSeahorseSteeringMessageIngested verifies steering messages appear in seahorse SQLite DB after being processed. * fix(seahorse): address 3 blocking bugs from code review - Fix resequenceContextItemsTx scan error handling (store.go:850) Changed `return err` to `return scanErr` to properly propagate scan errors instead of returning nil (which silently corrupts data) - Fix sql.NullString for INTEGER column (store.go:847) Changed `mid` from sql.NullString to sql.NullInt64 since message_id is INTEGER in schema. Removed unnecessary strconv.ParseInt call. - Fix compactCondensed fallback deleting non-candidate items Added ReplaceContextItemsWithSummary method for per-item deletion when candidates are not contiguous in ordinal space. Optimized to use range deletion when candidates are consecutive. * fix(seahorse): pass Budget to Compact for correct condensed threshold Issue #4 from PR review: When Budget was not passed to seahorse.Compact, it defaulted to `tokensBefore * 0.75`, making `tokensBefore > budget` always true and causing condensed compaction to trigger unnecessarily. Changes: - context_seahorse.go: Forward Budget from CompactRequest to CompactInput - loop.go: Pass Budget (ContextWindow) in all 3 Compact calls - Add test verifying condensed is skipped when tokens < threshold - Fix lint issues in store.go and store_test.go * fix(seahorse): add mutex for assembler lazy initialization Issue #5 from PR review: The check-then-create pattern for e.assembler was a data race when multiple goroutines called Assemble() concurrently: if e.assembler == nil { e.assembler = &Assembler{...} } Changes: - Add assemblerMu sync.Mutex to Engine struct - Add initAssemblerOnce() using double-checked locking (same pattern as initCompactionOnce) - Add TestAssemblerLazyInitRace to verify thread-safety * fix(seahorse): handle non-consecutive depths in selectShallowestCondensationCandidate Issue #8 from PR review: the loop iterated depth 0, 1, 2... assuming consecutive keys, but break when key was missing caused deeper depths to never be checked. Fix: collect all existing depth keys, sort, then iterate in order. * fix(seahorse): wrap DeleteMessagesAfterID and appendContextItems in transactions - DeleteMessagesAfterID: wrap all DELETE operations in a transaction for atomicity, remove redundant manual FTS delete (handled by trigger) - appendContextItems: use transaction to fix read-then-write race condition - Add GetMaxOrdinalTx and resolveItemTokenCountTx for transaction-scoped queries - Remove unused resolveItemTokenCount function Fixes PR review issues 6 and 7. * fix(seahorse): derive readable content from Parts and cap CompactUntilUnder iterations - Derive readable content from MessageParts in AddMessageWithParts so FTS5 indexing and summary formatting can access tool call information - formatMessagesForSummary and truncateSummary now fall back to Parts when Content is empty, fixing blank summaries for Part-based messages - Add MaxCompactIterations (20) to prevent CompactUntilUnder infinite loops; exceeded iterations are logged as warnings --- .gitignore | 2 + .golangci.yaml | 1 + pkg/agent/context_budget.go | 96 +- pkg/agent/context_budget_test.go | 38 +- pkg/agent/context_legacy.go | 2 +- pkg/agent/context_manager.go | 1 + pkg/agent/context_seahorse.go | 267 +++ pkg/agent/context_seahorse_test.go | 1086 +++++++++++++ pkg/agent/loop.go | 6 +- pkg/agent/subturn.go | 6 +- pkg/memory/jsonl.go | 27 + pkg/memory/store.go | 3 + pkg/seahorse/.omc/state/last-tool-error.json | 7 + pkg/seahorse/compact_until_under_test.go | 58 + pkg/seahorse/parts_roundtrip_test.go | 144 ++ pkg/seahorse/schema.go | 185 +++ pkg/seahorse/schema_test.go | 211 +++ pkg/seahorse/short_assembler.go | 261 +++ pkg/seahorse/short_assembler_test.go | 536 ++++++ pkg/seahorse/short_bench_test.go | 336 ++++ pkg/seahorse/short_compaction.go | 898 ++++++++++ pkg/seahorse/short_compaction_test.go | 974 +++++++++++ pkg/seahorse/short_constants.go | 30 + pkg/seahorse/short_engine.go | 568 +++++++ pkg/seahorse/short_engine_test.go | 1448 +++++++++++++++++ pkg/seahorse/short_retrieval.go | 212 +++ pkg/seahorse/short_retrieval_test.go | 362 +++++ pkg/seahorse/store.go | 1532 ++++++++++++++++++ pkg/seahorse/store_test.go | 1250 ++++++++++++++ pkg/seahorse/tool_expand.go | 129 ++ pkg/seahorse/tool_expand_test.go | 136 ++ pkg/seahorse/tool_grep.go | 172 ++ pkg/seahorse/tool_grep_test.go | 72 + pkg/seahorse/types.go | 161 ++ pkg/seahorse/types_test.go | 54 + pkg/session/jsonl_backend.go | 5 + pkg/session/manager.go | 10 + pkg/session/session_store.go | 2 + pkg/tokenizer/estimator.go | 91 ++ 39 files changed, 11271 insertions(+), 108 deletions(-) create mode 100644 pkg/agent/context_seahorse.go create mode 100644 pkg/agent/context_seahorse_test.go create mode 100644 pkg/seahorse/.omc/state/last-tool-error.json create mode 100644 pkg/seahorse/compact_until_under_test.go create mode 100644 pkg/seahorse/parts_roundtrip_test.go create mode 100644 pkg/seahorse/schema.go create mode 100644 pkg/seahorse/schema_test.go create mode 100644 pkg/seahorse/short_assembler.go create mode 100644 pkg/seahorse/short_assembler_test.go create mode 100644 pkg/seahorse/short_bench_test.go create mode 100644 pkg/seahorse/short_compaction.go create mode 100644 pkg/seahorse/short_compaction_test.go create mode 100644 pkg/seahorse/short_constants.go create mode 100644 pkg/seahorse/short_engine.go create mode 100644 pkg/seahorse/short_engine_test.go create mode 100644 pkg/seahorse/short_retrieval.go create mode 100644 pkg/seahorse/short_retrieval_test.go create mode 100644 pkg/seahorse/store.go create mode 100644 pkg/seahorse/store_test.go create mode 100644 pkg/seahorse/tool_expand.go create mode 100644 pkg/seahorse/tool_expand_test.go create mode 100644 pkg/seahorse/tool_grep.go create mode 100644 pkg/seahorse/tool_grep_test.go create mode 100644 pkg/seahorse/types.go create mode 100644 pkg/seahorse/types_test.go create mode 100644 pkg/tokenizer/estimator.go diff --git a/.gitignore b/.gitignore index b869ecc33..135867842 100644 --- a/.gitignore +++ b/.gitignore @@ -67,3 +67,5 @@ web/backend/dist/* .claude/ docker/data + +.omc/ diff --git a/.golangci.yaml b/.golangci.yaml index b2b772406..052e4c0dd 100644 --- a/.golangci.yaml +++ b/.golangci.yaml @@ -12,6 +12,7 @@ linters: - exhaustruct - funcorder - gochecknoglobals + - gosmopolitan # Project legitimately uses CJK text in tests (FTS5, token counting) - godot - intrange - ireturn diff --git a/pkg/agent/context_budget.go b/pkg/agent/context_budget.go index 3398d7863..72f80382a 100644 --- a/pkg/agent/context_budget.go +++ b/pkg/agent/context_budget.go @@ -6,10 +6,8 @@ package agent import ( - "encoding/json" - "unicode/utf8" - "github.com/sipeed/picoclaw/pkg/providers" + "github.com/sipeed/picoclaw/pkg/tokenizer" ) // parseTurnBoundaries returns the starting index of each Turn in the history. @@ -86,88 +84,16 @@ func findSafeBoundary(history []providers.Message, targetIndex int) int { return 0 } -// estimateMessageTokens estimates the token count for a single message, -// including Content, ReasoningContent, ToolCalls arguments, ToolCallID -// metadata, and Media items. Uses a heuristic of 2.5 characters per token. -func estimateMessageTokens(msg providers.Message) int { - contentChars := utf8.RuneCountInString(msg.Content) - - // SystemParts are structured system blocks used for cache-aware adapters. - // They carry the same content as Content, but in multiple blocks. - // We estimate them as an alternative representation, not additive. - systemPartsChars := 0 - if len(msg.SystemParts) > 0 { - for _, part := range msg.SystemParts { - systemPartsChars += utf8.RuneCountInString(part.Text) - } - // Per-part overhead for JSON structure (type, text, cache_control). - const perPartOverhead = 20 - systemPartsChars += len(msg.SystemParts) * perPartOverhead - } - - // Use the larger of the two representations to stay conservative. - chars := contentChars - if systemPartsChars > chars { - chars = systemPartsChars - } - - chars += utf8.RuneCountInString(msg.ReasoningContent) - - for _, tc := range msg.ToolCalls { - chars += len(tc.ID) + len(tc.Type) - if tc.Function != nil { - // Count function name + arguments (the wire format for most providers). - // tc.Name mirrors tc.Function.Name — count only once to avoid double-counting. - chars += len(tc.Function.Name) + len(tc.Function.Arguments) - } else { - // Fallback: some provider formats use top-level Name without Function. - chars += len(tc.Name) - } - } - - if msg.ToolCallID != "" { - chars += len(msg.ToolCallID) - } - - // Per-message overhead for role label, JSON structure, separators. - const messageOverhead = 12 - chars += messageOverhead - - tokens := chars * 2 / 5 - - // Media items (images, files) are serialized by provider adapters into - // multipart or image_url payloads. Add a fixed per-item token estimate - // directly (not through the chars heuristic) since actual cost depends - // on resolution and provider-specific image tokenization. - const mediaTokensPerItem = 256 - tokens += len(msg.Media) * mediaTokensPerItem - - return tokens +// EstimateMessageTokens estimates the token count for a single message. +// Delegates to the shared tokenizer package for consistency across agent and seahorse. +func EstimateMessageTokens(msg providers.Message) int { + return tokenizer.EstimateMessageTokens(msg) } -// estimateToolDefsTokens estimates the total token cost of tool definitions -// as they appear in the LLM request. Each tool's name, description, and -// JSON schema parameters contribute to the context window budget. -func estimateToolDefsTokens(defs []providers.ToolDefinition) int { - if len(defs) == 0 { - return 0 - } - - totalChars := 0 - for _, d := range defs { - totalChars += len(d.Function.Name) + len(d.Function.Description) - - if d.Function.Parameters != nil { - if paramJSON, err := json.Marshal(d.Function.Parameters); err == nil { - totalChars += len(paramJSON) - } - } - - // Per-tool overhead: type field, JSON structure, separators. - totalChars += 20 - } - - return totalChars * 2 / 5 +// EstimateToolDefsTokens estimates the total token cost of tool definitions +// as they appear in the LLM request. Delegates to the shared tokenizer package. +func EstimateToolDefsTokens(defs []providers.ToolDefinition) int { + return tokenizer.EstimateToolDefsTokens(defs) } // isOverContextBudget checks whether the assembled messages plus tool definitions @@ -181,10 +107,10 @@ func isOverContextBudget( ) bool { msgTokens := 0 for _, m := range messages { - msgTokens += estimateMessageTokens(m) + msgTokens += EstimateMessageTokens(m) } - toolTokens := estimateToolDefsTokens(toolDefs) + toolTokens := EstimateToolDefsTokens(toolDefs) total := msgTokens + toolTokens + maxTokens return total > contextWindow diff --git a/pkg/agent/context_budget_test.go b/pkg/agent/context_budget_test.go index 22cbdc0db..9de1707ec 100644 --- a/pkg/agent/context_budget_test.go +++ b/pkg/agent/context_budget_test.go @@ -417,9 +417,9 @@ func TestEstimateMessageTokens(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - got := estimateMessageTokens(tt.msg) + got := EstimateMessageTokens(tt.msg) if got < tt.want { - t.Errorf("estimateMessageTokens() = %d, want >= %d", got, tt.want) + t.Errorf("EstimateMessageTokens() = %d, want >= %d", got, tt.want) } }) } @@ -443,8 +443,8 @@ func TestEstimateMessageTokens_ToolCallsContribute(t *testing.T) { }, } - plainTokens := estimateMessageTokens(plain) - withTCTokens := estimateMessageTokens(withTC) + plainTokens := EstimateMessageTokens(plain) + withTCTokens := EstimateMessageTokens(withTC) if withTCTokens <= plainTokens { t.Errorf("message with ToolCalls (%d tokens) should exceed plain message (%d tokens)", @@ -457,7 +457,7 @@ func TestEstimateMessageTokens_MultibyteContent(t *testing.T) { // but may map to different token counts. The heuristic should still produce // reasonable estimates via RuneCountInString. msg := msgUser("caf\u00e9 na\u00efve r\u00e9sum\u00e9 \u00fcber stra\u00dfe") - tokens := estimateMessageTokens(msg) + tokens := EstimateMessageTokens(msg) if tokens <= 0 { t.Errorf("multibyte message should produce positive token count, got %d", tokens) } @@ -481,7 +481,7 @@ func TestEstimateMessageTokens_LargeArguments(t *testing.T) { }, } - tokens := estimateMessageTokens(msg) + tokens := EstimateMessageTokens(msg) // 5000+ chars → at least 2000 tokens with the 2.5 char/token heuristic if tokens < 2000 { t.Errorf("large tool call arguments should produce significant token count, got %d", tokens) @@ -496,8 +496,8 @@ func TestEstimateMessageTokens_ReasoningContent(t *testing.T) { ReasoningContent: strings.Repeat("thinking step ", 200), } - plainTokens := estimateMessageTokens(plain) - reasoningTokens := estimateMessageTokens(withReasoning) + plainTokens := EstimateMessageTokens(plain) + reasoningTokens := EstimateMessageTokens(withReasoning) if reasoningTokens <= plainTokens { t.Errorf("message with ReasoningContent (%d tokens) should exceed plain message (%d tokens)", @@ -513,8 +513,8 @@ func TestEstimateMessageTokens_MediaItems(t *testing.T) { Media: []string{"media://img1.png", "media://img2.png"}, } - plainTokens := estimateMessageTokens(plain) - mediaTokens := estimateMessageTokens(withMedia) + plainTokens := EstimateMessageTokens(plain) + mediaTokens := EstimateMessageTokens(withMedia) if mediaTokens <= plainTokens { t.Errorf("message with Media (%d tokens) should exceed plain message (%d tokens)", @@ -540,8 +540,8 @@ func TestEstimateMessageTokens_SystemParts(t *testing.T) { }, } - plainTokens := estimateMessageTokens(plain) - partsTokens := estimateMessageTokens(withParts) + plainTokens := EstimateMessageTokens(plain) + partsTokens := EstimateMessageTokens(withParts) if partsTokens <= plainTokens { t.Errorf("system message with SystemParts (%d) should exceed plain message (%d)", @@ -549,7 +549,7 @@ func TestEstimateMessageTokens_SystemParts(t *testing.T) { } } -// --- estimateToolDefsTokens tests --- +// --- EstimateToolDefsTokens tests --- func TestEstimateToolDefsTokens(t *testing.T) { tests := []struct { @@ -599,9 +599,9 @@ func TestEstimateToolDefsTokens(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - got := estimateToolDefsTokens(tt.defs) + got := EstimateToolDefsTokens(tt.defs) if got < tt.want { - t.Errorf("estimateToolDefsTokens() = %d, want >= %d", got, tt.want) + t.Errorf("EstimateToolDefsTokens() = %d, want >= %d", got, tt.want) } }) } @@ -624,8 +624,8 @@ func TestEstimateToolDefsTokens_ScalesWithCount(t *testing.T) { } } - one := estimateToolDefsTokens([]providers.ToolDefinition{makeTool("tool_a")}) - three := estimateToolDefsTokens([]providers.ToolDefinition{ + one := EstimateToolDefsTokens([]providers.ToolDefinition{makeTool("tool_a")}) + three := EstimateToolDefsTokens([]providers.ToolDefinition{ makeTool("tool_a"), makeTool("tool_b"), makeTool("tool_c"), }) @@ -770,7 +770,7 @@ func TestEstimateMessageTokens_WithReasoningAndMedia(t *testing.T) { }, } - tokens := estimateMessageTokens(msg) + tokens := EstimateMessageTokens(msg) // ReasoningContent alone is ~1700 chars → ~680 tokens. // Content + TC + overhead adds more. Should be well above 500. @@ -781,7 +781,7 @@ func TestEstimateMessageTokens_WithReasoningAndMedia(t *testing.T) { // Compare without reasoning to ensure it's counted. msgNoReasoning := msg msgNoReasoning.ReasoningContent = "" - tokensNoReasoning := estimateMessageTokens(msgNoReasoning) + tokensNoReasoning := EstimateMessageTokens(msgNoReasoning) if tokens <= tokensNoReasoning { t.Errorf("reasoning content should add tokens: with=%d, without=%d", tokens, tokensNoReasoning) diff --git a/pkg/agent/context_legacy.go b/pkg/agent/context_legacy.go index 23402460e..0f10decb3 100644 --- a/pkg/agent/context_legacy.go +++ b/pkg/agent/context_legacy.go @@ -373,7 +373,7 @@ func (m *legacyContextManager) summarizeBatch( func (m *legacyContextManager) estimateTokens(messages []providers.Message) int { total := 0 for _, msg := range messages { - total += estimateMessageTokens(msg) + total += EstimateMessageTokens(msg) } return total } diff --git a/pkg/agent/context_manager.go b/pkg/agent/context_manager.go index cc8904ccf..5f8701812 100644 --- a/pkg/agent/context_manager.go +++ b/pkg/agent/context_manager.go @@ -43,6 +43,7 @@ type AssembleResponse struct { type CompactRequest struct { SessionKey string // session identifier Reason ContextCompressReason // proactive_budget | llm_retry | summarize + Budget int // context window budget (used for retry aggressive compaction) } // IngestRequest is the input to Ingest. diff --git a/pkg/agent/context_seahorse.go b/pkg/agent/context_seahorse.go new file mode 100644 index 000000000..104a84a78 --- /dev/null +++ b/pkg/agent/context_seahorse.go @@ -0,0 +1,267 @@ +package agent + +import ( + "context" + "encoding/json" + "fmt" + + "github.com/sipeed/picoclaw/pkg/logger" + "github.com/sipeed/picoclaw/pkg/providers" + "github.com/sipeed/picoclaw/pkg/providers/protocoltypes" + "github.com/sipeed/picoclaw/pkg/seahorse" + "github.com/sipeed/picoclaw/pkg/session" + "github.com/sipeed/picoclaw/pkg/tokenizer" +) + +// seahorseContextManager adapts seahorse.Engine to agent.ContextManager. +type seahorseContextManager struct { + engine *seahorse.Engine + sessions session.SessionStore // for startup bootstrap +} + +// newSeahorseContextManager creates a seahorse-backed ContextManager. +func newSeahorseContextManager(_ json.RawMessage, al *AgentLoop) (ContextManager, error) { + if al == nil { + return nil, fmt.Errorf("seahorse: AgentLoop is required") + } + + // Resolve workspace for DB path + // DB stores session data, so it goes in sessions/ directory + agent := al.registry.GetDefaultAgent() + dbPath := agent.Workspace + "/sessions/seahorse.db" + + // Create CompleteFn from provider + completeFn := providerToCompleteFn(agent.Provider, agent.Model) + + // Create engine + engine, err := seahorse.NewEngine(seahorse.Config{ + DBPath: dbPath, + }, completeFn) + if err != nil { + return nil, fmt.Errorf("seahorse: create engine: %w", err) + } + + mgr := &seahorseContextManager{ + engine: engine, + sessions: agent.Sessions, + } + + // Register seahorse tools with the agent's tool registry + retrieval := mgr.engine.GetRetrieval() + al.RegisterTool(seahorse.NewGrepTool(retrieval)) + al.RegisterTool(seahorse.NewExpandTool(retrieval)) + + // Bootstrap all existing sessions at startup + if agent.Sessions != nil { + ctx := context.Background() + for _, sessionKey := range agent.Sessions.ListSessions() { + mgr.bootstrapSession(ctx, sessionKey) + } + } + + return mgr, nil +} + +// providerToCompleteFn wraps providers.LLMProvider as a seahorse.CompleteFn. +func providerToCompleteFn(provider providers.LLMProvider, model string) seahorse.CompleteFn { + return func(ctx context.Context, prompt string, opts seahorse.CompleteOptions) (string, error) { + resp, err := provider.Chat( + ctx, + []providers.Message{{Role: "user", Content: prompt}}, + nil, // no tools for summarization + model, + map[string]any{ + "max_tokens": opts.MaxTokens, + "temperature": opts.Temperature, + "prompt_cache_key": "seahorse", + }, + ) + if err != nil { + return "", err + } + return resp.Content, nil + } +} + +// Assemble builds budget-aware context from seahorse SQLite. +func (m *seahorseContextManager) Assemble(ctx context.Context, req *AssembleRequest) (*AssembleResponse, error) { + if req == nil { + return nil, fmt.Errorf("seahorse assemble: nil request") + } + + budget := req.Budget + if budget <= 0 { + budget = 100000 + } + + // Reserve space for model response (spec lines 1400-1410) + effectiveBudget := budget - req.MaxTokens + if effectiveBudget <= 0 { + // MaxTokens >= budget is a configuration problem + // Use 50% as minimum to avoid guaranteed overflow + logger.WarnCF("agent", "MaxTokens >= budget, using 50% fallback", + map[string]any{"budget": budget, "max_tokens": req.MaxTokens}) + effectiveBudget = budget / 2 + } + + result, err := m.engine.Assemble(ctx, req.SessionKey, seahorse.AssembleInput{ + Budget: effectiveBudget, + }) + if err != nil { + return nil, fmt.Errorf("seahorse assemble: %w", err) + } + + history := seahorseToProviderMessages(result) + + // Summary is already formatted as XML with system prompt addition by assembler + return &AssembleResponse{ + History: history, + Summary: result.Summary, + }, nil +} + +// Compact compresses conversation history via seahorse summarization. +func (m *seahorseContextManager) Compact(ctx context.Context, req *CompactRequest) error { + if req == nil { + return nil + } + + // For retry (LLM overflow), use aggressive CompactUntilUnder to guarantee + // context shrinks below budget (spec lines ~1410). + if req.Reason == ContextCompressReasonRetry && req.Budget > 0 { + _, err := m.engine.CompactUntilUnder(ctx, req.SessionKey, req.Budget) + return err + } + + _, err := m.engine.Compact(ctx, req.SessionKey, seahorse.CompactInput{ + Force: req.Reason == ContextCompressReasonRetry, + Budget: &req.Budget, + }) + return err +} + +// Ingest records a message into seahorse SQLite. +// All existing sessions are bootstrapped at startup, so this only ingests new messages. +func (m *seahorseContextManager) Ingest(ctx context.Context, req *IngestRequest) error { + if req == nil { + return nil + } + + msg := providerToSeahorseMessage(req.Message) + _, err := m.engine.Ingest(ctx, req.SessionKey, []seahorse.Message{msg}) + return err +} + +// bootstrapSession reconciles JSONL session history into seahorse SQLite. +func (m *seahorseContextManager) bootstrapSession(ctx context.Context, sessionKey string) { + if m.sessions == nil { + return + } + + history := m.sessions.GetHistory(sessionKey) + if len(history) == 0 { + return + } + + // Convert provider messages to seahorse messages + msgs := make([]seahorse.Message, len(history)) + for i, h := range history { + msgs[i] = providerToSeahorseMessage(h) + } + + if err := m.engine.Bootstrap(ctx, sessionKey, msgs); err != nil { + logger.WarnCF("seahorse", "bootstrap", map[string]any{ + "session": sessionKey, + "error": err.Error(), + }) + } +} + +// providerToSeahorseMessage converts a providers.Message to a seahorse.Message. +func providerToSeahorseMessage(msg protocoltypes.Message) seahorse.Message { + result := seahorse.Message{ + Role: msg.Role, + Content: msg.Content, + ReasoningContent: msg.ReasoningContent, + TokenCount: tokenizer.EstimateMessageTokens(msg), + } + + // Convert ToolCalls → MessageParts + for _, tc := range msg.ToolCalls { + part := seahorse.MessagePart{ + Type: "tool_use", + Name: tc.Function.Name, + Arguments: tc.Function.Arguments, + ToolCallID: tc.ID, + } + result.Parts = append(result.Parts, part) + } + + // Convert tool result + if msg.ToolCallID != "" { + part := seahorse.MessagePart{ + Type: "tool_result", + ToolCallID: msg.ToolCallID, + Text: msg.Content, + } + result.Parts = append(result.Parts, part) + } + + // Convert media attachments + for _, mediaURI := range msg.Media { + part := seahorse.MessagePart{ + Type: "media", + MediaURI: mediaURI, + } + result.Parts = append(result.Parts, part) + } + + return result +} + +// seahorseToProviderMessages converts a seahorse.AssembleResult to []providers.Message. +func seahorseToProviderMessages(result *seahorse.AssembleResult) []protocoltypes.Message { + messages := make([]protocoltypes.Message, 0, len(result.Messages)) + + // Convert assembled messages (which already include summary XML messages) + for _, msg := range result.Messages { + pm := protocoltypes.Message{ + Role: msg.Role, + Content: msg.Content, + ReasoningContent: msg.ReasoningContent, + } + + // Reconstruct ToolCalls from parts + for _, part := range msg.Parts { + if part.Type == "tool_use" { + pm.ToolCalls = append(pm.ToolCalls, protocoltypes.ToolCall{ + ID: part.ToolCallID, + Type: "function", // Required by OpenAI-compatible APIs (GLM, etc.) + Function: &protocoltypes.FunctionCall{ + Name: part.Name, + Arguments: part.Arguments, + }, + }) + } + if part.Type == "tool_result" { + pm.ToolCallID = part.ToolCallID + if pm.Content == "" && part.Text != "" { + pm.Content = part.Text + } + } + if part.Type == "media" && part.MediaURI != "" { + pm.Media = append(pm.Media, part.MediaURI) + } + } + + messages = append(messages, pm) + } + + return messages +} + +func init() { + if err := RegisterContextManager("seahorse", newSeahorseContextManager); err != nil { + panic(fmt.Sprintf("register seahorse context manager: %v", err)) + } +} diff --git a/pkg/agent/context_seahorse_test.go b/pkg/agent/context_seahorse_test.go new file mode 100644 index 000000000..e405ef944 --- /dev/null +++ b/pkg/agent/context_seahorse_test.go @@ -0,0 +1,1086 @@ +package agent + +import ( + "context" + "fmt" + "strings" + "testing" + "time" + + "github.com/sipeed/picoclaw/pkg/bus" + "github.com/sipeed/picoclaw/pkg/config" + "github.com/sipeed/picoclaw/pkg/providers" + "github.com/sipeed/picoclaw/pkg/providers/protocoltypes" + "github.com/sipeed/picoclaw/pkg/seahorse" +) + +// seahorseTestProvider implements providers.LLMProvider for seahorse tests. +type seahorseTestProvider struct { + chatFn func(ctx context.Context, messages []providers.Message, tools []providers.ToolDefinition, model string, options map[string]any) (*providers.LLMResponse, error) +} + +func (m *seahorseTestProvider) Chat( + ctx context.Context, + messages []providers.Message, + tools []providers.ToolDefinition, + model string, + options map[string]any, +) (*providers.LLMResponse, error) { + if m.chatFn != nil { + return m.chatFn(ctx, messages, tools, model, options) + } + return &providers.LLMResponse{Content: "mock response"}, nil +} + +func (m *seahorseTestProvider) GetDefaultModel() string { + return "mock-model" +} + +func TestSeahorseCMRegistration(t *testing.T) { + factory, ok := lookupContextManager("seahorse") + if !ok { + t.Error("expected 'seahorse' context manager to be registered") + } + if factory == nil { + t.Error("expected non-nil factory") + } +} + +func TestProviderToSeahorseMessage(t *testing.T) { + tests := []struct { + name string + input protocoltypes.Message + wantRole string + wantContent string + }{ + { + name: "simple user message", + input: protocoltypes.Message{Role: "user", Content: "hello world"}, + wantRole: "user", + wantContent: "hello world", + }, + { + name: "assistant message", + input: protocoltypes.Message{Role: "assistant", Content: "response text"}, + wantRole: "assistant", + wantContent: "response text", + }, + { + name: "tool result message", + input: protocoltypes.Message{Role: "tool", Content: "tool output", ToolCallID: "tc_123"}, + wantRole: "tool", + wantContent: "tool output", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := providerToSeahorseMessage(tt.input) + if result.Role != tt.wantRole { + t.Errorf("Role = %q, want %q", result.Role, tt.wantRole) + } + if result.Content != tt.wantContent { + t.Errorf("Content = %q, want %q", result.Content, tt.wantContent) + } + }) + } +} + +func TestProviderToSeahorseMessageWithToolCalls(t *testing.T) { + msg := protocoltypes.Message{ + Role: "assistant", + Content: "", + ToolCalls: []protocoltypes.ToolCall{ + { + ID: "tc_1", + Function: &protocoltypes.FunctionCall{ + Name: "read_file", + Arguments: `{"path":"/tmp/test"}`, + }, + }, + }, + } + + result := providerToSeahorseMessage(msg) + if result.Role != "assistant" { + t.Errorf("Role = %q, want assistant", result.Role) + } + if len(result.Parts) == 0 { + t.Fatal("expected at least 1 part from tool calls") + } + if result.Parts[0].Type != "tool_use" { + t.Errorf("Part type = %q, want tool_use", result.Parts[0].Type) + } + if result.Parts[0].Name != "read_file" { + t.Errorf("Part name = %q, want read_file", result.Parts[0].Name) + } + if result.Parts[0].ToolCallID != "tc_1" { + t.Errorf("Part ToolCallID = %q, want tc_1", result.Parts[0].ToolCallID) + } +} + +func TestProviderToSeahorseMessageWithToolResult(t *testing.T) { + msg := protocoltypes.Message{ + Role: "tool", + Content: "file contents here", + ToolCallID: "tc_456", + } + + result := providerToSeahorseMessage(msg) + if result.Role != "tool" { + t.Errorf("Role = %q, want tool", result.Role) + } + found := false + for _, p := range result.Parts { + if p.Type == "tool_result" && p.ToolCallID == "tc_456" { + found = true + break + } + } + if !found { + t.Error("expected tool_result part with ToolCallID tc_456") + } +} + +func TestProviderToSeahorseMessageWithMedia(t *testing.T) { + msg := protocoltypes.Message{ + Role: "user", + Content: "Here is an image", + Media: []string{"data:image/png;base64,abc123"}, + } + + result := providerToSeahorseMessage(msg) + if result.Role != "user" { + t.Errorf("Role = %q, want user", result.Role) + } + + // Should have a media part + found := false + for _, p := range result.Parts { + if p.Type == "media" { + found = true + if p.MediaURI != "data:image/png;base64,abc123" { + t.Errorf("MediaURI = %q, want data:image/png;base64,abc123", p.MediaURI) + } + break + } + } + if !found { + t.Error("expected media part in converted message") + } +} + +func TestProviderToSeahorseMessageWithReasoning(t *testing.T) { + msg := protocoltypes.Message{ + Role: "assistant", + Content: "response text", + ReasoningContent: "I thought about this carefully", + } + + result := providerToSeahorseMessage(msg) + if result.ReasoningContent != "I thought about this carefully" { + t.Errorf("ReasoningContent = %q, want 'I thought about this carefully'", result.ReasoningContent) + } +} + +func TestSeahorseToProviderMessagesWithReasoning(t *testing.T) { + result := &seahorse.AssembleResult{ + Messages: []seahorse.Message{ + { + Role: "assistant", + Content: "response", + ReasoningContent: "thinking process", + }, + }, + } + + messages := seahorseToProviderMessages(result) + if len(messages) != 1 { + t.Fatalf("expected 1 message, got %d", len(messages)) + } + if messages[0].ReasoningContent != "thinking process" { + t.Errorf("ReasoningContent = %q, want 'thinking process'", messages[0].ReasoningContent) + } +} + +func TestSeahorseToProviderMessages(t *testing.T) { + // Summaries should NOT be double-injected. + // The assembler already includes summaries as XML-formatted messages in Messages slice. + // seahorseToProviderMessages should only convert Messages, not Summaries. + summaryXML := ` + + test summary content + +` + summaryMsg := seahorse.Message{ + Role: "user", + Content: summaryXML, + TokenCount: 50, + } + rawMsg := seahorse.Message{ + Role: "user", + Content: "hello", + TokenCount: 5, + } + + result := seahorseToProviderMessages(&seahorse.AssembleResult{ + Messages: []seahorse.Message{summaryMsg, rawMsg}, + }) + + // Should have exactly 2 messages (from Messages slice only) + // NOT 3 (which would happen if Summaries were also converted) + if len(result) != 2 { + t.Fatalf("expected exactly 2 messages (no double injection), got %d", len(result)) + } + // First should be the XML summary message + if result[0].Content != summaryXML { + t.Errorf("first message content = %q, want summary XML", result[0].Content) + } + // Second should be the raw message + if result[1].Content != "hello" { + t.Errorf("second message content = %q, want 'hello'", result[1].Content) + } +} + +func TestSeahorseToProviderMessagesWithToolCalls(t *testing.T) { + msg := seahorse.Message{ + Role: "assistant", + Content: "", + TokenCount: 10, + Parts: []seahorse.MessagePart{ + { + Type: "tool_use", + Name: "read_file", + Arguments: `{"path":"/tmp"}`, + ToolCallID: "tc_1", + }, + }, + } + + result := seahorseToProviderMessages(&seahorse.AssembleResult{ + Messages: []seahorse.Message{msg}, + }) + + if len(result) != 1 { + t.Fatalf("expected 1 message, got %d", len(result)) + } + if result[0].Role != "assistant" { + t.Errorf("Role = %q, want assistant", result[0].Role) + } + if len(result[0].ToolCalls) != 1 { + t.Fatalf("ToolCalls = %d, want 1", len(result[0].ToolCalls)) + } + if result[0].ToolCalls[0].Function.Name != "read_file" { + t.Errorf("ToolCall name = %q, want read_file", result[0].ToolCalls[0].Function.Name) + } + // GLM API and other OpenAI-compatible APIs require Type: "function" + if result[0].ToolCalls[0].Type != "function" { + t.Errorf("ToolCall Type = %q, want 'function' (required by GLM/OpenAI APIs)", + result[0].ToolCalls[0].Type) + } +} + +func TestSeahorseToProviderMessagesToolResult(t *testing.T) { + msg := seahorse.Message{ + Role: "tool", + Content: "file output", + TokenCount: 5, + Parts: []seahorse.MessagePart{ + { + Type: "tool_result", + ToolCallID: "tc_99", + Text: "file output", + }, + }, + } + + result := seahorseToProviderMessages(&seahorse.AssembleResult{ + Messages: []seahorse.Message{msg}, + }) + + if len(result) != 1 { + t.Fatalf("expected 1 message, got %d", len(result)) + } + if result[0].ToolCallID != "tc_99" { + t.Errorf("ToolCallID = %q, want tc_99", result[0].ToolCallID) + } +} + +// --- providerToCompleteFn tests --- + +func TestProviderToCompleteFn(t *testing.T) { + var capturedMessages []providers.Message + var capturedModel string + var capturedOptions map[string]any + + mp := &seahorseTestProvider{ + chatFn: func(ctx context.Context, messages []providers.Message, tools []providers.ToolDefinition, model string, options map[string]any) (*providers.LLMResponse, error) { + capturedMessages = messages + capturedModel = model + capturedOptions = options + return &providers.LLMResponse{Content: "summary of conversation"}, nil + }, + } + + completeFn := providerToCompleteFn(mp, "test-model-v1") + result, err := completeFn(context.Background(), "Summarize this text", seahorse.CompleteOptions{ + MaxTokens: 500, + Temperature: 0.3, + }) + if err != nil { + t.Fatalf("completeFn: %v", err) + } + if result != "summary of conversation" { + t.Errorf("result = %q, want 'summary of conversation'", result) + } + + // Verify prompt passed as user message + if len(capturedMessages) != 1 { + t.Fatalf("captured messages = %d, want 1", len(capturedMessages)) + } + if capturedMessages[0].Role != "user" { + t.Errorf("message role = %q, want user", capturedMessages[0].Role) + } + if capturedMessages[0].Content != "Summarize this text" { + t.Errorf("message content = %q, want 'Summarize this text'", capturedMessages[0].Content) + } + + // Verify model + if capturedModel != "test-model-v1" { + t.Errorf("model = %q, want 'test-model-v1'", capturedModel) + } + + // Verify options + if capturedOptions["max_tokens"] != 500 { + t.Errorf("max_tokens = %v, want 500", capturedOptions["max_tokens"]) + } + if capturedOptions["temperature"] != 0.3 { + t.Errorf("temperature = %v, want 0.3", capturedOptions["temperature"]) + } + if capturedOptions["prompt_cache_key"] != "seahorse" { + t.Errorf("prompt_cache_key = %v, want 'seahorse'", capturedOptions["prompt_cache_key"]) + } +} + +func TestSeahorseIgnoreHeartbeat(t *testing.T) { + // Verify that "heartbeat" sessions are ignored by default + // This tests the hardcoded ignore pattern from spec lines 1326-1328 + engine, err := seahorse.NewEngine(seahorse.Config{ + DBPath: t.TempDir() + "/test.db", + }, nil) + if err != nil { + t.Fatalf("NewEngine: %v", err) + } + defer engine.Close() + + ctx := context.Background() + result, err := engine.Ingest(ctx, "heartbeat", []seahorse.Message{ + {Role: "user", Content: "heartbeat msg", TokenCount: 5}, + }) + if err != nil { + t.Fatalf("Ingest: %v", err) + } + // Should return nil nil for ignored sessions + if result != nil { + t.Errorf("expected nil result for heartbeat session, got %+v", result) + } +} + +func TestProviderToCompleteFnError(t *testing.T) { + mp := &seahorseTestProvider{ + chatFn: func(ctx context.Context, messages []providers.Message, tools []providers.ToolDefinition, model string, options map[string]any) (*providers.LLMResponse, error) { + return nil, context.Canceled + }, + } + + completeFn := providerToCompleteFn(mp, "test-model") + _, err := completeFn(context.Background(), "test prompt", seahorse.CompleteOptions{}) + if err == nil { + t.Error("expected error from canceled context") + } +} + +func TestSeahorseAdapterAssembleSubtractsMaxTokens(t *testing.T) { + // Create a real seahorse engine with temp DB + engine, err := seahorse.NewEngine(seahorse.Config{ + DBPath: t.TempDir() + "/test.db", + }, nil) + if err != nil { + t.Fatalf("NewEngine: %v", err) + } + defer engine.Close() + + ctx := context.Background() + mgr := &seahorseContextManager{engine: engine} + + // Ingest lots of large messages (~35 tokens each, 120 total = ~4200 tokens) + for i := 0; i < 60; i++ { + content := fmt.Sprintf( + "This is message number %d. It contains enough text to represent a meaningful conversation turn with the user asking about various topics in software engineering and system design principles that require careful consideration.", + i, + ) + _ = mgr.Ingest(ctx, &IngestRequest{ + SessionKey: "budget-sub", + Message: protocoltypes.Message{Role: "user", Content: content}, + }) + _ = mgr.Ingest(ctx, &IngestRequest{ + SessionKey: "budget-sub", + Message: protocoltypes.Message{Role: "assistant", Content: "Response"}, + }) + } + + // Call adapter Assemble with Budget=5000, MaxTokens=2000 + // Should use effective budget = 5000 - 2000 = 3000 + resp, err := mgr.Assemble(ctx, &AssembleRequest{ + SessionKey: "budget-sub", + Budget: 5000, + MaxTokens: 2000, + }) + if err != nil { + t.Fatalf("Assemble: %v", err) + } + if resp == nil { + t.Fatal("expected non-nil response") + } + + // Directly call engine with budget=3000 to get baseline + baseline, err := engine.Assemble(ctx, "budget-sub", seahorse.AssembleInput{Budget: 3000}) + if err != nil { + t.Fatalf("engine.Assemble baseline: %v", err) + } + + // The adapter result should have same message count as engine with budget 3000 + if len(resp.History) != len(baseline.Messages) { + t.Errorf("adapter Budget=5000 MaxTokens=2000 gave %d messages, engine Budget=3000 gave %d", + len(resp.History), len(baseline.Messages)) + } +} + +func TestSeahorseCompactRetryUsesCompactUntilUnder(t *testing.T) { + // Track which engine method was called + var compactCalled, compactUntilCalled bool + + engine, err := seahorse.NewEngine(seahorse.Config{ + DBPath: t.TempDir() + "/test.db", + }, nil) + if err != nil { + t.Fatalf("NewEngine: %v", err) + } + defer engine.Close() + + // Wrap engine to track calls + _ = compactCalled // track via adapter behavior + _ = compactUntilCalled + + mgr := &seahorseContextManager{engine: engine} + + ctx := context.Background() + + // Ingest messages so there's something to compact + for i := 0; i < 40; i++ { + content := fmt.Sprintf( + "message %d with enough text to have meaningful token count that fills up the budget nicely", + i, + ) + _ = mgr.Ingest(ctx, &IngestRequest{ + SessionKey: "compact-test", + Message: protocoltypes.Message{Role: "user", Content: content}, + }) + _ = mgr.Ingest(ctx, &IngestRequest{ + SessionKey: "compact-test", + Message: protocoltypes.Message{Role: "assistant", Content: "ok"}, + }) + } + + // Compact with retry reason and budget should succeed + err = mgr.Compact(ctx, &CompactRequest{ + SessionKey: "compact-test", + Reason: ContextCompressReasonRetry, + Budget: 5000, + }) + if err != nil { + t.Fatalf("Compact retry: %v", err) + } + + // Verify context was actually compacted (should have fewer tokens) + result, err := engine.Assemble(ctx, "compact-test", seahorse.AssembleInput{Budget: 5000}) + if err != nil { + t.Fatalf("Assemble after compact: %v", err) + } + if result == nil { + t.Fatal("expected non-nil assemble result") + } + // Compaction attempted — no assertion on exact count since no LLM + _ = result.Summary +} + +// TestSeahorseRealLoopNoDuplicateMessages tests the real-world scenario: +// 1. Start AgentLoop with seahorse context manager +// 2. Run a turn (user message -> LLM response) +// 3. Check DB for duplicate messages +// This test verifies that bootstrapping at startup (not during first Ingest) prevents duplicates. +func TestSeahorseRealLoopNoDuplicateMessages(t *testing.T) { + cfg := &config.Config{ + Agents: config.AgentsConfig{ + Defaults: config.AgentDefaults{ + Workspace: t.TempDir(), + ModelName: "test-model", + MaxTokens: 4096, + MaxToolIterations: 10, + ContextManager: "seahorse", + }, + }, + } + + msgBus := bus.NewMessageBus() + mockProvider := &simpleMockProvider{response: "I received your message."} + al := NewAgentLoop(cfg, msgBus, mockProvider) + defaultAgent := al.registry.GetDefaultAgent() + if defaultAgent == nil { + t.Fatal("expected default agent") + } + + ctx := context.Background() + sessionKey := "test-real-loop-dup" + + // Run a turn: user message -> LLM response + _, err := al.runAgentLoop(ctx, defaultAgent, processOptions{ + SessionKey: sessionKey, + Channel: "cli", + ChatID: "direct", + UserMessage: "hello", + DefaultResponse: defaultResponse, + EnableSummary: false, + SendResponse: false, + }) + if err != nil { + t.Fatalf("runAgentLoop failed: %v", err) + } + + // Get the seahorse engine from context manager + seahorseCM, ok := al.contextManager.(*seahorseContextManager) + if !ok { + t.Fatal("expected seahorseContextManager") + } + + // Check DB for messages via RetrievalEngine.Store() + store := seahorseCM.engine.GetRetrieval().Store() + conv, err := store.GetOrCreateConversation(ctx, sessionKey) + if err != nil { + t.Fatalf("GetOrCreateConversation: %v", err) + } + + stored, err := store.GetMessages(ctx, conv.ConversationID, 20, 0) + if err != nil { + t.Fatalf("GetMessages: %v", err) + } + + t.Logf("DB has %d messages:", len(stored)) + for i, msg := range stored { + content := msg.Content + if len(content) > 40 { + content = content[:40] + "..." + } + t.Logf(" msg[%d]: role=%s content=%q", i, msg.Role, content) + } + + // Count duplicates by (role, content) + seen := make(map[string]int) + for _, msg := range stored { + key := msg.Role + ":" + msg.Content + seen[key]++ + } + for key, count := range seen { + if count > 1 { + t.Errorf("DUPLICATE BUG: %q appears %d times in DB", key, count) + } + } + + // Expected: 2 messages (user "hello" + assistant response) + if len(stored) != 2 { + t.Errorf("expected 2 messages in DB (user + assistant), got %d", len(stored)) + } +} + +// TestSeahorseAssembleReturnsAllSummaries verifies that Assemble returns ALL summaries, +// not just the latest one. This is important because summaries represent compressed +// conversation history at different points in time. +func TestSeahorseAssembleReturnsAllSummaries(t *testing.T) { + // Create a real seahorse engine with temp DB + engine, err := seahorse.NewEngine(seahorse.Config{ + DBPath: t.TempDir() + "/test.db", + }, nil) + if err != nil { + t.Fatalf("NewEngine: %v", err) + } + defer engine.Close() + + ctx := context.Background() + mgr := &seahorseContextManager{engine: engine} + sessionKey := "test-multi-summary" + + // Get the store to directly create summaries + store := engine.GetRetrieval().Store() + + // Get conversation ID + conv, err := store.GetOrCreateConversation(ctx, sessionKey) + if err != nil { + t.Fatalf("GetOrCreateConversation: %v", err) + } + + // Create some messages first + for i := 0; i < 20; i++ { + _ = mgr.Ingest(ctx, &IngestRequest{ + SessionKey: sessionKey, + Message: protocoltypes.Message{Role: "user", Content: fmt.Sprintf("Message %d", i)}, + }) + } + + // Directly create multiple summaries in the database to simulate multi-level compaction + testSummaries := []struct { + content string + kind seahorse.SummaryKind + depth int + token int + }{ + {"First summary about early conversation discussing topics A and B", seahorse.SummaryKindLeaf, 0, 100}, + {"Second summary covering middle conversation about topics C and D", seahorse.SummaryKindLeaf, 0, 150}, + {"Third summary is condensed from first two summaries about topics A-D", seahorse.SummaryKindCondensed, 1, 200}, + } + + summaryIDs := make([]string, 0, len(testSummaries)) + for _, s := range testSummaries { + input := seahorse.CreateSummaryInput{ + ConversationID: conv.ConversationID, + Kind: s.kind, + Depth: s.depth, + Content: s.content, + TokenCount: s.token, + } + summary, createErr := store.CreateSummary(ctx, input) + if createErr != nil { + t.Fatalf("CreateSummary: %v", createErr) + } + summaryIDs = append(summaryIDs, summary.SummaryID) + + // Add summary to context_items + err = store.AppendContextSummary(ctx, conv.ConversationID, summary.SummaryID) + if err != nil { + t.Fatalf("AppendContextSummary: %v", err) + } + } + + t.Logf("Created %d summaries directly in store", len(summaryIDs)) + + // Assemble and check summaries + resp, err := mgr.Assemble(ctx, &AssembleRequest{ + SessionKey: sessionKey, + Budget: 50000, + MaxTokens: 4096, + }) + if err != nil { + t.Fatalf("Assemble: %v", err) + } + + // Check seahorse engine directly for how many summaries exist + result, err := engine.Assemble(ctx, sessionKey, seahorse.AssembleInput{Budget: 50000}) + if err != nil { + t.Fatalf("engine.Assemble: %v", err) + } + + t.Logf("Seahorse returned Summary with %d chars", len(result.Summary)) + + // The Summary field should contain XML summaries with metadata (depth, kind) + // The assembler generates this from the Summaries list + if len(resp.Summary) > 0 { + // Should contain XML tag + if !strings.Contains(resp.Summary, " Content-only = %d", + resultWithToolCalls.TokenCount, resultContentOnly.TokenCount) + } + + // Message with ToolCallID + msgWithToolResult := protocoltypes.Message{ + Role: "tool", + Content: "This is a simple response with some text content.", + ToolCallID: "tc_456", + } + resultWithToolResult := providerToSeahorseMessage(msgWithToolResult) + + if resultWithToolResult.TokenCount <= resultContentOnly.TokenCount { + t.Errorf("TokenCount with ToolCallID = %d, should be > Content-only = %d", + resultWithToolResult.TokenCount, resultContentOnly.TokenCount) + } + + // Message with Media + msgWithMedia := protocoltypes.Message{ + Role: "user", + Content: "This is a simple response with some text content.", + Media: []string{"data:image/png;base64,abc123"}, + } + resultWithMedia := providerToSeahorseMessage(msgWithMedia) + + if resultWithMedia.TokenCount <= resultContentOnly.TokenCount { + t.Errorf("TokenCount with Media = %d, should be > Content-only = %d", + resultWithMedia.TokenCount, resultContentOnly.TokenCount) + } +} + +func TestSeahorseToProviderMessagesRebuildsContentFromParts(t *testing.T) { + msg := seahorse.Message{ + Role: "tool", + Content: "", + TokenCount: 50, + Parts: []seahorse.MessagePart{ + { + Type: "tool_result", + ToolCallID: "tc_999", + Text: "This is the actual tool output that should be in Content", + }, + }, + } + + result := seahorseToProviderMessages(&seahorse.AssembleResult{ + Messages: []seahorse.Message{msg}, + }) + + if len(result) != 1 { + t.Fatalf("expected 1 message, got %d", len(result)) + } + + if result[0].Content == "" { + t.Error("Content is empty - tool_result text was not rebuilt into Content") + } + if result[0].Content != "This is the actual tool output that should be in Content" { + t.Errorf("Content = %q, want tool output text from Parts", result[0].Content) + } +} + +func TestSeahorseAssembleSummaryNotInMessages(t *testing.T) { + engine, err := seahorse.NewEngine(seahorse.Config{ + DBPath: t.TempDir() + "/test.db", + }, nil) + if err != nil { + t.Fatalf("NewEngine: %v", err) + } + defer engine.Close() + + ctx := context.Background() + mgr := &seahorseContextManager{engine: engine} + sessionKey := "test-no-dup-summary" + + // Get the store to directly create a summary + store := engine.GetRetrieval().Store() + conv, err := store.GetOrCreateConversation(ctx, sessionKey) + if err != nil { + t.Fatalf("GetOrCreateConversation: %v", err) + } + + // Ingest some messages first + for i := 0; i < 10; i++ { + _ = mgr.Ingest(ctx, &IngestRequest{ + SessionKey: sessionKey, + Message: protocoltypes.Message{Role: "user", Content: fmt.Sprintf("Message %d", i)}, + }) + } + + // Create a summary + input := seahorse.CreateSummaryInput{ + ConversationID: conv.ConversationID, + Kind: seahorse.SummaryKindLeaf, + Depth: 0, + Content: "This is a test summary about the conversation", + TokenCount: 50, + } + summary, err := store.CreateSummary(ctx, input) + if err != nil { + t.Fatalf("CreateSummary: %v", err) + } + err = store.AppendContextSummary(ctx, conv.ConversationID, summary.SummaryID) + if err != nil { + t.Fatalf("AppendContextSummary: %v", err) + } + + // Assemble + resp, err := mgr.Assemble(ctx, &AssembleRequest{ + SessionKey: sessionKey, + Budget: 50000, + MaxTokens: 4096, + }) + if err != nil { + t.Fatalf("Assemble: %v", err) + } + + // Count how many times the summary content appears + summaryContent := "This is a test summary" + countInHistory := 0 + for _, msg := range resp.History { + if strings.Contains(msg.Content, summaryContent) { + countInHistory++ + } + } + + if countInHistory > 0 { + t.Errorf("Summary content appears %d times in History - should be 0", countInHistory) + } + + // Summary should appear in Summary field + if !strings.Contains(resp.Summary, summaryContent) { + t.Error("Summary content should appear in response.Summary field") + } +} + +// TestSeahorseSteeringMessageIngested verifies that steering messages are ingested +// into seahorse SQLite, not just session JSONL. +func TestSeahorseSteeringMessageIngested(t *testing.T) { + cfg := &config.Config{ + Agents: config.AgentsConfig{ + Defaults: config.AgentDefaults{ + Workspace: t.TempDir(), + ModelName: "test-model", + MaxTokens: 4096, + MaxToolIterations: 10, + ContextManager: "seahorse", + }, + }, + } + + msgBus := bus.NewMessageBus() + mockProvider := &simpleMockProvider{response: "I received your message."} + al := NewAgentLoop(cfg, msgBus, mockProvider) + defaultAgent := al.registry.GetDefaultAgent() + if defaultAgent == nil { + t.Fatal("expected default agent") + } + + ctx := context.Background() + sessionKey := "test-steering-ingest" + + // First turn: establish conversation + _, err := al.runAgentLoop(ctx, defaultAgent, processOptions{ + SessionKey: sessionKey, + Channel: "cli", + ChatID: "direct", + UserMessage: "hello", + DefaultResponse: defaultResponse, + EnableSummary: false, + SendResponse: false, + }) + if err != nil { + t.Fatalf("first runAgentLoop failed: %v", err) + } + + // Inject a steering message + steerErr := al.InjectSteering(providers.Message{ + Role: "user", + Content: "steering message content", + }) + if steerErr != nil { + t.Fatalf("InjectSteering failed: %v", steerErr) + } + + // Second turn: should process steering message + _, err = al.runAgentLoop(ctx, defaultAgent, processOptions{ + SessionKey: sessionKey, + Channel: "cli", + ChatID: "direct", + UserMessage: "continue", + DefaultResponse: defaultResponse, + EnableSummary: false, + SendResponse: false, + }) + if err != nil { + t.Fatalf("second runAgentLoop failed: %v", err) + } + + // Get the seahorse engine from context manager + seahorseCM, ok := al.contextManager.(*seahorseContextManager) + if !ok { + t.Fatal("expected seahorseContextManager") + } + + // Check DB for steering message + store := seahorseCM.engine.GetRetrieval().Store() + conv, err := store.GetOrCreateConversation(ctx, sessionKey) + if err != nil { + t.Fatalf("GetOrCreateConversation: %v", err) + } + + stored, err := store.GetMessages(ctx, conv.ConversationID, 20, 0) + if err != nil { + t.Fatalf("GetMessages: %v", err) + } + + t.Logf("DB has %d messages:", len(stored)) + for i, msg := range stored { + content := msg.Content + if len(content) > 40 { + content = content[:40] + "..." + } + t.Logf(" msg[%d]: role=%s content=%q", i, msg.Role, content) + } + + // Find steering message in stored messages + foundSteering := false + for _, msg := range stored { + if msg.Content == "steering message content" { + foundSteering = true + break + } + } + + if !foundSteering { + t.Error("STEERING MESSAGE NOT IN SEAHORSE DB: steering message should be ingested into SQLite") + } +} + +// TestSeahorseSummarizeSkipsCondensedWhenBelowThreshold verifies that when +// Summarize is triggered but tokens are below ContextWindow threshold, +// condensed compaction should NOT run. +func TestSeahorseSummarizeSkipsCondensedWhenBelowThreshold(t *testing.T) { + contextWindow := 1000 + cfg := &config.Config{ + Agents: config.AgentsConfig{ + Defaults: config.AgentDefaults{ + Workspace: t.TempDir(), + ModelName: "test-model", + MaxTokens: 4096, + MaxToolIterations: 10, + ContextManager: "seahorse", + ContextWindow: contextWindow, + }, + }, + } + + msgBus := bus.NewMessageBus() + provider := &seahorseTestProvider{} + al := NewAgentLoop(cfg, msgBus, provider) + defaultAgent := al.registry.GetDefaultAgent() + if defaultAgent == nil { + t.Fatal("expected default agent") + } + + ctx := context.Background() + sessionKey := "test-summarize-skip-condensed" + + seahorseCM, ok := al.contextManager.(*seahorseContextManager) + if !ok { + t.Fatal("expected seahorseContextManager") + } + store := seahorseCM.engine.GetRetrieval().Store() + + conv, err := store.GetOrCreateConversation(ctx, sessionKey) + if err != nil { + t.Fatalf("GetOrCreateConversation: %v", err) + } + + // Insert leaf summaries directly (bypass leaf compaction requirement) + for i := 0; i < seahorse.CondensedMinFanout; i++ { + now := time.Now().UTC() + summary, sumErr := store.CreateSummary(ctx, seahorse.CreateSummaryInput{ + ConversationID: conv.ConversationID, + Kind: seahorse.SummaryKindLeaf, + Depth: 0, + Content: fmt.Sprintf("leaf summary %d", i), + TokenCount: 50, + EarliestAt: &now, + LatestAt: &now, + }) + if sumErr != nil { + t.Fatalf("CreateSummary %d: %v", i, sumErr) + } + if appendErr := store.AppendContextSummary(ctx, conv.ConversationID, summary.SummaryID); appendErr != nil { + t.Fatalf("AppendContextSummary %d: %v", i, appendErr) + } + } + + // Add fresh messages (required for condensation candidates) + for i := 0; i < seahorse.FreshTailCount+1; i++ { + m, msgErr := store.AddMessage(ctx, conv.ConversationID, "user", "fresh", 5) + if msgErr != nil { + t.Fatalf("AddMessage %d: %v", i, msgErr) + } + if appendErr := store.AppendContextMessage(ctx, conv.ConversationID, m.ID); appendErr != nil { + t.Fatalf("AppendContextMessage %d: %v", i, appendErr) + } + } + + tokensBefore, err := store.GetContextTokenCount(ctx, conv.ConversationID) + if err != nil { + t.Fatalf("GetContextTokenCount: %v", err) + } + threshold := int(float64(contextWindow) * seahorse.ContextThreshold) + t.Logf("Tokens before: %d, threshold: %d", tokensBefore, threshold) + + // Trigger Summarize + _, err = al.runAgentLoop(ctx, defaultAgent, processOptions{ + SessionKey: sessionKey, + Channel: "cli", + ChatID: "direct", + UserMessage: "trigger", + DefaultResponse: defaultResponse, + EnableSummary: true, + SendResponse: false, + }) + if err != nil { + t.Fatalf("runAgentLoop: %v", err) + } + + time.Sleep(500 * time.Millisecond) + + summaries, err := store.GetSummariesByConversation(ctx, conv.ConversationID) + if err != nil { + t.Fatalf("GetSummariesByConversation: %v", err) + } + + condensedCount := 0 + for _, sum := range summaries { + if sum.Kind == seahorse.SummaryKindCondensed { + condensedCount++ + } + } + + t.Logf("Condensed summaries: %d", condensedCount) + + if tokensBefore < threshold && condensedCount > 0 { + t.Errorf("BUG: condensed created when tokens (%d) < threshold (%d)", tokensBefore, threshold) + } +} diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go index 808d12c07..fc37ff8a0 100644 --- a/pkg/agent/loop.go +++ b/pkg/agent/loop.go @@ -1742,6 +1742,7 @@ func (al *AgentLoop) runTurn(ctx context.Context, ts *turnState) (turnResult, er if err := al.contextManager.Compact(turnCtx, &CompactRequest{ SessionKey: ts.sessionKey, Reason: ContextCompressReasonProactive, + Budget: ts.agent.ContextWindow, }); err != nil { logger.WarnCF("agent", "Proactive compact failed", map[string]any{ "session_key": ts.sessionKey, @@ -1857,6 +1858,7 @@ turnLoop: if !ts.opts.NoHistory { ts.agent.Sessions.AddFullMessage(ts.sessionKey, pm) ts.recordPersistedMessage(pm) + ts.ingestMessage(turnCtx, al, pm) } logger.InfoCF("agent", "Injected steering message into context", map[string]any{ @@ -2128,6 +2130,7 @@ turnLoop: if compactErr := al.contextManager.Compact(turnCtx, &CompactRequest{ SessionKey: ts.sessionKey, Reason: ContextCompressReasonRetry, + Budget: ts.agent.ContextWindow, }); compactErr != nil { logger.WarnCF("agent", "Context overflow compact failed", map[string]any{ "session_key": ts.sessionKey, @@ -2773,7 +2776,7 @@ turnLoop: } } if ts.opts.EnableSummary { - al.contextManager.Compact(turnCtx, &CompactRequest{SessionKey: ts.sessionKey, Reason: ContextCompressReasonSummarize}) + al.contextManager.Compact(turnCtx, &CompactRequest{SessionKey: ts.sessionKey, Reason: ContextCompressReasonSummarize, Budget: ts.agent.ContextWindow}) } ts.setPhase(TurnPhaseCompleted) @@ -2849,6 +2852,7 @@ turnLoop: &CompactRequest{ SessionKey: ts.sessionKey, Reason: ContextCompressReasonSummarize, + Budget: ts.agent.ContextWindow, }, ) } diff --git a/pkg/agent/subturn.go b/pkg/agent/subturn.go index 9447f1384..9ee7b15c9 100644 --- a/pkg/agent/subturn.go +++ b/pkg/agent/subturn.go @@ -604,6 +604,7 @@ type ephemeralSessionStoreIface interface { SetHistory(key string, history []providers.Message) TruncateHistory(key string, keepLast int) Save(key string) error + ListSessions() []string Close() error } @@ -663,8 +664,9 @@ func (e *ephemeralSessionStore) TruncateHistory(_ string, keepLast int) { e.history = e.history[len(e.history)-keepLast:] } -func (e *ephemeralSessionStore) Save(_ string) error { return nil } -func (e *ephemeralSessionStore) Close() error { return nil } +func (e *ephemeralSessionStore) Save(_ string) error { return nil } +func (e *ephemeralSessionStore) Close() error { return nil } +func (e *ephemeralSessionStore) ListSessions() []string { return nil } func (e *ephemeralSessionStore) truncateLocked() { if len(e.history) > maxEphemeralHistorySize { diff --git a/pkg/memory/jsonl.go b/pkg/memory/jsonl.go index afe374166..fc1ec8eb1 100644 --- a/pkg/memory/jsonl.go +++ b/pkg/memory/jsonl.go @@ -455,6 +455,33 @@ func (s *JSONLStore) rewriteJSONL( return fileutil.WriteFileAtomic(s.jsonlPath(sessionKey), buf.Bytes(), 0o644) } +// ListSessions returns all known session keys by reading .meta.json files. +func (s *JSONLStore) ListSessions() []string { + entries, err := os.ReadDir(s.dir) + if err != nil { + return nil + } + var keys []string + for _, entry := range entries { + if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".meta.json") { + continue + } + // Read the meta file to get the original key + data, err := os.ReadFile(filepath.Join(s.dir, entry.Name())) + if err != nil { + continue + } + var meta sessionMeta + if err := json.Unmarshal(data, &meta); err != nil { + continue + } + if meta.Key != "" { + keys = append(keys, meta.Key) + } + } + return keys +} + func (s *JSONLStore) Close() error { return nil } diff --git a/pkg/memory/store.go b/pkg/memory/store.go index b6e11707d..11526b27c 100644 --- a/pkg/memory/store.go +++ b/pkg/memory/store.go @@ -37,6 +37,9 @@ type Store interface { // data. Backends that do not accumulate dead data may return nil. Compact(ctx context.Context, sessionKey string) error + // ListSessions returns all known session keys. + ListSessions() []string + // Close releases any resources held by the store. Close() error } diff --git a/pkg/seahorse/.omc/state/last-tool-error.json b/pkg/seahorse/.omc/state/last-tool-error.json new file mode 100644 index 000000000..2e7273e23 --- /dev/null +++ b/pkg/seahorse/.omc/state/last-tool-error.json @@ -0,0 +1,7 @@ +{ + "tool_name": "Bash", + "tool_input_preview": "{\"command\":\"cd /home/yliu/repos/picoclaw && make lint 2>&1\",\"timeout\":120000}", + "error": "Exit code 2\npkg/agent/context_seahorse_test.go:1027:1: File is not properly formatted (gci)\n\t\t\tEarliestAt: &now,\n^\n1 issues:\n* gci: 1\nmake: *** [Makefile:264: lint] Error 1", + "timestamp": "2026-04-04T02:38:32.067Z", + "retry_count": 6 +} \ No newline at end of file diff --git a/pkg/seahorse/compact_until_under_test.go b/pkg/seahorse/compact_until_under_test.go new file mode 100644 index 000000000..2bb96c263 --- /dev/null +++ b/pkg/seahorse/compact_until_under_test.go @@ -0,0 +1,58 @@ +package seahorse + +import ( + "context" + "testing" +) + +// ============================================================================= +// CompactUntilUnder iteration cap +// ============================================================================= + +func TestCompactUntilUnderIterationCap(t *testing.T) { + // Setup: create a conversation with so many tokens that compaction + // will never reach the budget. The iteration cap prevents infinite loops. + // + // We use a mock CompleteFn that always returns the same content, + // and a budget of 0 which tokens can never reach. + // Without the cap, this would loop forever. + + db := openTestDB(t) + if err := runSchema(db); err != nil { + t.Fatalf("migration: %v", err) + } + s := &Store{db: db} + + conv, _ := s.GetOrCreateConversation(context.Background(), "agent:iter-cap") + convID := conv.ConversationID + + // Add many messages to ensure there's plenty to compact + for i := 0; i < 40; i++ { + m, _ := s.AddMessage(context.Background(), convID, "user", + "this is a long message with lots of tokens to push context over budget", 100) + s.AppendContextMessage(context.Background(), convID, m.ID) + } + + // A completeFn that always succeeds but returns non-reducing content + mockComplete := func(ctx context.Context, prompt string, opts CompleteOptions) (string, error) { + return "Summary that doesn't reduce tokens much.", nil + } + + ce, cancel := newTestCompactionEngineWithStore(s, mockComplete) + defer cancel() + + // Use budget=1 so tokens can never reach budget + // (each message is 100 tokens, so 40 messages = 4000 tokens, budget 1 is unreachable) + // The function should stop after maxCompactIterations, not loop forever + ce.config = Config{} // ensure defaults + + result, err := ce.CompactUntilUnder(context.Background(), convID, 1) + if err != nil { + // Should not error — should stop gracefully + t.Fatalf("CompactUntilUnder with budget=0: %v", err) + } + + // The function should have completed within reasonable time + // If it exceeded the cap, it would still return (not hang) + _ = result +} diff --git a/pkg/seahorse/parts_roundtrip_test.go b/pkg/seahorse/parts_roundtrip_test.go new file mode 100644 index 000000000..02df8a9ea --- /dev/null +++ b/pkg/seahorse/parts_roundtrip_test.go @@ -0,0 +1,144 @@ +package seahorse + +import ( + "context" + "testing" + "time" +) + +// ============================================================================= +// Bug 1: formatMessagesForSummary ignores Parts +// - formatMessagesForSummary only reads m.Content, empty for Part-based messages +// - truncateSummary has same issue +// ============================================================================= + +func TestFormatMessagesForSummaryIncludesParts(t *testing.T) { + ts := time.Date(2025, 1, 1, 12, 0, 0, 0, time.UTC) + + messages := []Message{ + {ID: 1, Role: "user", Content: "hello world", CreatedAt: ts}, + { + ID: 2, + Role: "assistant", + Content: "", // empty — real content is in Parts + Parts: []MessagePart{ + {Type: "text", Text: "I will run a command"}, + {Type: "tool_use", Name: "bash", Arguments: `{"command":"ls -la"}`, ToolCallID: "call_1"}, + }, + CreatedAt: ts.Add(time.Minute), + }, + { + ID: 3, + Role: "tool", + Content: "", // empty — real content is in Parts + Parts: []MessagePart{ + {Type: "tool_result", Text: "file1.txt\nfile2.txt", ToolCallID: "call_1"}, + }, + CreatedAt: ts.Add(2 * time.Minute), + }, + } + + result := formatMessagesForSummary(messages) + + // Must contain the plain text message + if !contains(result, "hello world") { + t.Error("formatMessagesForSummary: missing plain text content") + } + + // Must contain tool_use info (not blank) + if !contains(result, "bash") || !contains(result, "ls -la") { + t.Errorf("formatMessagesForSummary: tool_use info missing from Parts.\nGot:\n%s", result) + } + + // Must contain tool_result info (not blank) + if !contains(result, "file1.txt") { + t.Errorf("formatMessagesForSummary: tool_result text missing from Parts.\nGot:\n%s", result) + } +} + +func TestTruncateSummaryIncludesParts(t *testing.T) { + messages := []Message{ + {ID: 1, Role: "user", Content: "run the tests", CreatedAt: time.Now()}, + { + ID: 2, + Role: "assistant", + Content: "", // empty + Parts: []MessagePart{ + {Type: "tool_use", Name: "bash", Arguments: `{"command":"go test ./..."}`, ToolCallID: "call_1"}, + }, + CreatedAt: time.Now(), + }, + { + ID: 3, + Role: "tool", + Content: "", // empty + Parts: []MessagePart{ + {Type: "tool_result", Text: "PASS\nok 3.2s", ToolCallID: "call_1"}, + }, + CreatedAt: time.Now(), + }, + } + + result := truncateSummary(messages) + + // Must contain plain text + if !contains(result, "run the tests") { + t.Error("truncateSummary: missing plain text content") + } + + // Must contain tool info from Parts (not blank) + if !contains(result, "bash") || !contains(result, "go test") { + t.Errorf("truncateSummary: tool_use info missing from Parts.\nGot:\n%s", result) + } + + // Must contain tool_result from Parts + if !contains(result, "PASS") { + t.Errorf("truncateSummary: tool_result text missing from Parts.\nGot:\n%s", result) + } +} + +// ============================================================================= +// Bug 2: SearchMessages cannot find Part-based messages +// - FTS5 indexes empty content, LIKE queries empty content +// ============================================================================= + +func TestSearchMessagesFindsPartBasedMessages(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:search-parts") + convID := conv.ConversationID + + // Add a plain message (searchable) + s.AddMessage(ctx, convID, "user", "list the files please", 5) + + // Add a Part-based message (tool_use) — currently NOT searchable + parts := []MessagePart{ + {Type: "tool_use", Name: "bash", Arguments: `{"command":"grep -r TODO ."}`, ToolCallID: "call_1"}, + } + s.AddMessageWithParts(ctx, convID, "assistant", parts, 10) + + // Add a Part-based message (tool_result) — currently NOT searchable + resultParts := []MessagePart{ + {Type: "tool_result", Text: "main.go:42: TODO fix this bug", ToolCallID: "call_1"}, + } + s.AddMessageWithParts(ctx, convID, "tool", resultParts, 10) + + // Search for "grep" — should find the tool_use message + results, err := s.SearchMessages(ctx, SearchInput{Pattern: "grep"}) + if err != nil { + t.Fatalf("SearchMessages: %v", err) + } + if len(results) == 0 { + t.Error("SearchMessages: 'grep' not found — Part-based messages are invisible to search") + } + + // Search for "TODO fix" — should find the tool_result message + results2, err := s.SearchMessages(ctx, SearchInput{Pattern: "TODO fix"}) + if err != nil { + t.Fatalf("SearchMessages: %v", err) + } + if len(results2) == 0 { + t.Error("SearchMessages: 'TODO fix' not found — tool_result messages are invisible to search") + } +} diff --git a/pkg/seahorse/schema.go b/pkg/seahorse/schema.go new file mode 100644 index 000000000..effa6d60d --- /dev/null +++ b/pkg/seahorse/schema.go @@ -0,0 +1,185 @@ +package seahorse + +import ( + "database/sql" + "fmt" + + "github.com/sipeed/picoclaw/pkg/logger" +) + +// SQL statements for FTS5 tables with trigram tokenizer. +const ( + sqlCreateSummariesFTS = `CREATE VIRTUAL TABLE IF NOT EXISTS summaries_fts USING fts5( + summary_id, + content, + tokenize="trigram" + )` + sqlCreateMessagesFTS = `CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5( + message_id, + content, + tokenize="trigram" + )` + sqlCheckFTS5Available = `CREATE VIRTUAL TABLE IF NOT EXISTS _fts5_check USING fts5(content)` + sqlCheckTrigramAvailable = `CREATE VIRTUAL TABLE IF NOT EXISTS _trigram_check USING fts5(content, tokenize="trigram")` + sqlDropFTS5Check = `DROP TABLE IF EXISTS _fts5_check` + sqlDropTrigramCheck = `DROP TABLE IF EXISTS _trigram_check` +) + +// runSchema creates or upgrades the database schema. +// All schemas are idempotent (safe to run multiple times). +func runSchema(db *sql.DB) error { + // Check FTS5 support before creating tables + if err := checkFTS5Support(db); err != nil { + return fmt.Errorf("FTS5 check: %w", err) + } + + stmts := []string{ + `CREATE TABLE IF NOT EXISTS conversations ( + conversation_id INTEGER PRIMARY KEY AUTOINCREMENT, + session_key TEXT NOT NULL UNIQUE, + created_at TEXT NOT NULL DEFAULT (datetime('now')), + updated_at TEXT NOT NULL DEFAULT (datetime('now')) + )`, + + `CREATE TABLE IF NOT EXISTS messages ( + message_id INTEGER PRIMARY KEY AUTOINCREMENT, + conversation_id INTEGER NOT NULL REFERENCES conversations(conversation_id), + role TEXT NOT NULL, + content TEXT NOT NULL DEFAULT '', + token_count INTEGER NOT NULL DEFAULT 0, + created_at TEXT NOT NULL DEFAULT (datetime('now')) + )`, + + `CREATE TABLE IF NOT EXISTS message_parts ( + part_id INTEGER PRIMARY KEY AUTOINCREMENT, + message_id INTEGER NOT NULL REFERENCES messages(message_id), + type TEXT NOT NULL, + text TEXT, + name TEXT, + arguments TEXT, + tool_call_id TEXT, + media_uri TEXT, + mime_type TEXT, + ordinal INTEGER NOT NULL DEFAULT 0 + )`, + + `CREATE TABLE IF NOT EXISTS summaries ( + summary_id TEXT PRIMARY KEY, + conversation_id INTEGER NOT NULL REFERENCES conversations(conversation_id), + kind TEXT NOT NULL, + depth INTEGER NOT NULL DEFAULT 0, + content TEXT NOT NULL, + token_count INTEGER NOT NULL DEFAULT 0, + earliest_at TEXT, + latest_at TEXT, + descendant_count INTEGER NOT NULL DEFAULT 0, + descendant_token_count INTEGER NOT NULL DEFAULT 0, + source_message_token_count INTEGER NOT NULL DEFAULT 0, + model TEXT, + created_at TEXT NOT NULL DEFAULT (datetime('now')) + )`, + + `CREATE TABLE IF NOT EXISTS summary_parents ( + summary_id TEXT NOT NULL, + parent_summary_id TEXT NOT NULL, + PRIMARY KEY (summary_id, parent_summary_id) + )`, + + `CREATE TABLE IF NOT EXISTS summary_messages ( + summary_id TEXT NOT NULL, + message_id INTEGER NOT NULL, + ordinal INTEGER NOT NULL DEFAULT 0, + PRIMARY KEY (summary_id, message_id) + )`, + + `CREATE TABLE IF NOT EXISTS context_items ( + conversation_id INTEGER NOT NULL, + ordinal INTEGER NOT NULL, + item_type TEXT NOT NULL, + summary_id TEXT, + message_id INTEGER, + token_count INTEGER NOT NULL DEFAULT 0, + created_at TEXT NOT NULL DEFAULT (datetime('now')), + PRIMARY KEY (conversation_id, ordinal) + )`, + + // FTS5 virtual table with trigram tokenizer for CJK support + sqlCreateSummariesFTS, + + // FTS5 virtual table for message search with trigram tokenizer + sqlCreateMessagesFTS, + + // Indexes for common query patterns + `CREATE INDEX IF NOT EXISTS idx_messages_conversation ON messages(conversation_id)`, + `CREATE INDEX IF NOT EXISTS idx_messages_created ON messages(conversation_id, created_at)`, + `CREATE INDEX IF NOT EXISTS idx_summaries_conversation ON summaries(conversation_id)`, + `CREATE INDEX IF NOT EXISTS idx_summaries_kind_depth ON summaries(conversation_id, kind, depth)`, + `CREATE INDEX IF NOT EXISTS idx_summary_parents_parent ON summary_parents(parent_summary_id)`, + `CREATE INDEX IF NOT EXISTS idx_summary_messages_message ON summary_messages(message_id)`, + `CREATE INDEX IF NOT EXISTS idx_context_items_conv ON context_items(conversation_id, ordinal)`, + + // FTS5 triggers to keep summaries_fts in sync with summaries table + `CREATE TRIGGER IF NOT EXISTS summaries_ai AFTER INSERT ON summaries BEGIN + INSERT INTO summaries_fts (summary_id, content) VALUES (new.summary_id, new.content); + END`, + `CREATE TRIGGER IF NOT EXISTS summaries_ad AFTER DELETE ON summaries BEGIN + INSERT INTO summaries_fts (summaries_fts, summary_id, content) VALUES ('delete', old.summary_id, old.content); + END`, + `CREATE TRIGGER IF NOT EXISTS summaries_au AFTER UPDATE ON summaries BEGIN + INSERT INTO summaries_fts (summaries_fts, summary_id, content) VALUES ('delete', old.summary_id, old.content); + INSERT INTO summaries_fts (summary_id, content) VALUES (new.summary_id, new.content); + END`, + + // FTS5 triggers to keep messages_fts in sync with messages table + `CREATE TRIGGER IF NOT EXISTS messages_ai AFTER INSERT ON messages BEGIN + INSERT INTO messages_fts (message_id, content) VALUES (new.message_id, new.content); + END`, + `CREATE TRIGGER IF NOT EXISTS messages_ad AFTER DELETE ON messages BEGIN + DELETE FROM messages_fts WHERE message_id = old.message_id; + END`, + `CREATE TRIGGER IF NOT EXISTS messages_au AFTER UPDATE ON messages BEGIN + DELETE FROM messages_fts WHERE message_id = old.message_id; + INSERT INTO messages_fts (message_id, content) VALUES (new.message_id, new.content); + END`, + } + + for _, s := range stmts { + if _, err := db.Exec(s); err != nil { + return err + } + } + return nil +} + +// checkFTS5Support verifies that SQLite has FTS5 with trigram tokenizer enabled. +// This is required for full-text search with CJK (Chinese, Japanese, Korean) support. +func checkFTS5Support(db *sql.DB) error { + // Check if FTS5 is compiled in + var fts5Enabled int + err := db.QueryRow(`SELECT sqlite_compileoption_used('ENABLE_FTS5')`).Scan(&fts5Enabled) + if err != nil { + // sqlite_compileoption_used might not exist in older SQLite + // Try a different approach: create a test FTS5 table + _, testErr := db.Exec(sqlCheckFTS5Available) + if testErr != nil { + return fmt.Errorf("SQLite FTS5 not available: %w (required for full-text search)", testErr) + } + db.Exec(sqlDropFTS5Check) + } else if fts5Enabled == 0 { + return fmt.Errorf("SQLite was compiled without FTS5 support (required for full-text search)") + } + + // Check if trigram tokenizer is available by trying to create a test table + // Not all SQLite builds include the trigram tokenizer + _, err = db.Exec(sqlCheckTrigramAvailable) + if err != nil { + logger.WarnCF("seahorse", "SQLite trigram tokenizer not available, CJK search may be limited", + map[string]any{"error": err.Error()}) + // Trigram is not strictly required, just better for CJK + // Don't return error, just log warning + } else { + db.Exec(sqlDropTrigramCheck) + } + + return nil +} diff --git a/pkg/seahorse/schema_test.go b/pkg/seahorse/schema_test.go new file mode 100644 index 000000000..17879f66c --- /dev/null +++ b/pkg/seahorse/schema_test.go @@ -0,0 +1,211 @@ +package seahorse + +import ( + "database/sql" + "testing" + + _ "modernc.org/sqlite" +) + +func openTestDB(t *testing.T) *sql.DB { + t.Helper() + db, err := sql.Open("sqlite", ":memory:") + if err != nil { + t.Fatalf("open test db: %v", err) + } + t.Cleanup(func() { db.Close() }) + return db +} + +func TestRunMigrations(t *testing.T) { + db := openTestDB(t) + + if err := runSchema(db); err != nil { + t.Fatalf("runSchema: %v", err) + } + + // Verify all tables exist + tables := []string{ + "conversations", + "messages", + "message_parts", + "summaries", + "summary_parents", + "summary_messages", + "context_items", + } + for _, tbl := range tables { + var name string + err := db.QueryRow( + "SELECT name FROM sqlite_master WHERE type='table' AND name=?", tbl, + ).Scan(&name) + if err != nil { + t.Errorf("table %q not found: %v", tbl, err) + } + } + + // Verify FTS5 virtual table exists + var ftsName string + err := db.QueryRow( + "SELECT name FROM sqlite_master WHERE type='table' AND name='summaries_fts'", + ).Scan(&ftsName) + if err != nil { + t.Errorf("FTS5 table summaries_fts not found: %v", err) + } +} + +func TestRunMigrationsIdempotent(t *testing.T) { + db := openTestDB(t) + + // Run migrations twice — should succeed both times + if err := runSchema(db); err != nil { + t.Fatalf("first migration: %v", err) + } + if err := runSchema(db); err != nil { + t.Fatalf("second migration (idempotent): %v", err) + } + + // Verify we can still insert data after double migration + res, err := db.Exec( + "INSERT INTO conversations (session_key, created_at, updated_at) VALUES (?, datetime('now'), datetime('now'))", + "test-session", + ) + if err != nil { + t.Fatalf("insert after double migration: %v", err) + } + id, _ := res.LastInsertId() + if id == 0 { + t.Error("expected non-zero conversation id") + } +} + +func TestMigrationConversationUnique(t *testing.T) { + db := openTestDB(t) + if err := runSchema(db); err != nil { + t.Fatalf("migration: %v", err) + } + + // Insert first + _, err := db.Exec( + "INSERT INTO conversations (session_key, created_at, updated_at) VALUES (?, datetime('now'), datetime('now'))", + "unique-key", + ) + if err != nil { + t.Fatalf("first insert: %v", err) + } + + // Duplicate should fail + _, err = db.Exec( + "INSERT INTO conversations (session_key, created_at, updated_at) VALUES (?, datetime('now'), datetime('now'))", + "unique-key", + ) + if err == nil { + t.Error("expected unique constraint violation for duplicate session_key") + } +} + +func TestMigrationSummaryFTSInsert(t *testing.T) { + db := openTestDB(t) + if err := runSchema(db); err != nil { + t.Fatalf("migration: %v", err) + } + + // Insert a conversation first + _, err := db.Exec( + "INSERT INTO conversations (session_key, created_at, updated_at) VALUES (?, datetime('now'), datetime('now'))", + "fts-test", + ) + if err != nil { + t.Fatalf("insert conversation: %v", err) + } + + // Insert a summary + _, err = db.Exec( + `INSERT INTO summaries (summary_id, conversation_id, kind, depth, content, token_count, created_at) + VALUES ('sum_test1', 1, 'leaf', 0, '你好世界 hello world', 10, datetime('now'))`) + if err != nil { + t.Fatalf("insert summary: %v", err) + } + + // FTS should find it — trigram tokenizer requires >= 3 chars + rows, err := db.Query( + "SELECT summary_id FROM summaries_fts WHERE summaries_fts MATCH ?", + "你好世", + ) + if err != nil { + t.Fatalf("FTS query: %v", err) + } + defer rows.Close() + + var found string + if rows.Next() { + if err := rows.Scan(&found); err != nil { + t.Fatalf("scan: %v", err) + } + } + if err := rows.Err(); err != nil { + t.Fatalf("rows.Err: %v", err) + } + if found != "sum_test1" { + t.Errorf("FTS: expected 'sum_test1', got %q", found) + } +} + +func TestMigrationSummaryParentsPK(t *testing.T) { + db := openTestDB(t) + if err := runSchema(db); err != nil { + t.Fatalf("migration: %v", err) + } + + // Insert two summaries + for _, id := range []string{"sum_a", "sum_b"} { + _, err := db.Exec( + `INSERT INTO summaries (summary_id, conversation_id, kind, depth, content, token_count, created_at) + VALUES (?, 1, 'leaf', 0, 'content', 5, datetime('now'))`, id) + if err != nil { + t.Fatalf("insert summary %s: %v", id, err) + } + } + + // Link child to parent + _, err := db.Exec( + "INSERT INTO summary_parents (summary_id, parent_summary_id) VALUES ('sum_a', 'sum_b')") + if err != nil { + t.Fatalf("link: %v", err) + } + + // Duplicate link should fail (composite PK) + _, err = db.Exec( + "INSERT INTO summary_parents (summary_id, parent_summary_id) VALUES ('sum_a', 'sum_b')") + if err == nil { + t.Error("expected unique constraint violation for duplicate summary_parents link") + } +} + +func TestFTS5SQLConstants(t *testing.T) { + db := openTestDB(t) + + // Verify FTS5 check SQL executes without error + _, err := db.Exec(sqlCheckFTS5Available) + if err != nil { + t.Errorf("sqlCheckFTS5Available failed: %v", err) + } + + // Verify trigram check SQL executes without error + _, err = db.Exec(sqlCheckTrigramAvailable) + if err != nil { + t.Errorf("sqlCheckTrigramAvailable failed: %v", err) + } + + // Verify summaries_fts SQL executes without error + _, err = db.Exec(sqlCreateSummariesFTS) + if err != nil { + t.Errorf("sqlCreateSummariesFTS failed: %v", err) + } + + // Verify messages_fts SQL executes without error + _, err = db.Exec(sqlCreateMessagesFTS) + if err != nil { + t.Errorf("sqlCreateMessagesFTS failed: %v", err) + } +} diff --git a/pkg/seahorse/short_assembler.go b/pkg/seahorse/short_assembler.go new file mode 100644 index 000000000..f0fd323ba --- /dev/null +++ b/pkg/seahorse/short_assembler.go @@ -0,0 +1,261 @@ +package seahorse + +import ( + "context" + "fmt" + "strings" + "time" + + "github.com/sipeed/picoclaw/pkg/logger" +) + +// escapeXML escapes special characters for safe inclusion in XML content. +func escapeXML(s string) string { + s = strings.ReplaceAll(s, "&", "&") + s = strings.ReplaceAll(s, "<", "<") + s = strings.ReplaceAll(s, ">", ">") + s = strings.ReplaceAll(s, "\"", """) + s = strings.ReplaceAll(s, "'", "'") + return s +} + +// resolvedItem is a context item resolved to its full content with token count. +type resolvedItem struct { + ordinal int + itemType string // "message" or "summary" + message *Message + summary *Summary + tokenCount int +} + +// Assemble builds budget-constrained context from summaries + messages. +// +// Algorithm: +// 1. Fetch context_items, resolve to full content +// 2. Split into evictable prefix + protected fresh tail +// 3. If evictable fits in remaining budget → include all +// 4. Else walk evictable from newest to oldest, keep while fits +func (a *Assembler) Assemble(ctx context.Context, convID int64, input AssembleInput) (*AssembleResult, error) { + items, err := a.store.GetContextItems(ctx, convID) + if err != nil { + return nil, fmt.Errorf("get context items: %w", err) + } + if len(items) == 0 { + return &AssembleResult{}, nil + } + + // Resolve all items + resolved := make([]resolvedItem, len(items)) + for i, item := range items { + r, err := a.resolveItem(ctx, item) + if err != nil { + return nil, err + } + resolved[i] = r + } + + // Split into evictable prefix and protected fresh tail + tailStart := len(resolved) - FreshTailCount + if tailStart < 0 { + tailStart = 0 + } + evictable := resolved[:tailStart] + freshTail := resolved[tailStart:] + + // Calculate fresh tail tokens + freshTailTokens := 0 + for _, r := range freshTail { + freshTailTokens += r.tokenCount + } + + // Budget-aware selection of evictable items + remainingBudget := input.Budget - freshTailTokens + if remainingBudget < 0 { + // Fresh tail alone exceeds budget - we keep it anyway (design decision) + // Log for debugging retry/overflow issues + logger.InfoCF("seahorse", "assemble: fresh tail exceeds budget", map[string]any{ + "budget": input.Budget, + "fresh_tail_tokens": freshTailTokens, + "fresh_tail_count": len(freshTail), + "over_budget_by": freshTailTokens - input.Budget, + }) + remainingBudget = 0 + } + + var selected []resolvedItem + evictableTokens := 0 + for _, r := range evictable { + evictableTokens += r.tokenCount + } + + if evictableTokens <= remainingBudget { + // All evictable fit + selected = append(selected, evictable...) + } else { + // Walk from newest to oldest, keep while fits + var kept []resolvedItem + accum := 0 + for i := len(evictable) - 1; i >= 0; i-- { + if accum+evictable[i].tokenCount <= remainingBudget { + kept = append(kept, evictable[i]) + accum += evictable[i].tokenCount + } else { + break + } + } + // Reverse to restore chronological order + for i, j := 0, len(kept)-1; i < j; i, j = i+1, j-1 { + kept[i], kept[j] = kept[j], kept[i] + } + selected = append(selected, kept...) + } + + // Combine: selected evictable + fresh tail + final := append(selected, freshTail...) + + // Build result + var messages []Message + var summaries []Summary + var sourceIDs []string + totalTokens := 0 + maxDepth := 0 + condensedCount := 0 + + for _, r := range final { + totalTokens += r.tokenCount + if r.itemType == "message" && r.message != nil { + messages = append(messages, *r.message) + sourceIDs = append(sourceIDs, fmt.Sprintf("msg:%d", r.message.ID)) + } else if r.itemType == "summary" && r.summary != nil { + summaries = append(summaries, *r.summary) + if r.summary.Depth > maxDepth { + maxDepth = r.summary.Depth + } + if r.summary.Kind == SummaryKindCondensed { + condensedCount++ + } + } + } + + // Build depth-aware system prompt addition + systemPromptAddition := "" + if len(summaries) > 0 { + if maxDepth >= 2 || condensedCount >= 2 { + systemPromptAddition = "Your context has been heavily compressed through multi-level summarization.\n" + + "- Do NOT assert specific facts (commands, SHAs, paths, timestamps) from summaries without expanding.\n" + + "- When uncertain, use expand to recover original detail before making claims.\n" + + "- Tool escalation: grep \xe2\x86\x92 describe \xe2\x86\x92 expand" + } else { + systemPromptAddition = "Some earlier messages have been summarized. Use expand tools to recover details if needed." + } + } + + // Build Summary field: all XML summaries + system prompt addition + var summaryParts []string + for _, sum := range summaries { + if sum.Content == "" { + continue + } + // Load parent IDs for XML formatting + parentSummaries, err := a.store.GetSummaryParents(ctx, sum.SummaryID) + if err != nil { + logger.WarnCF("seahorse", "assemble: get summary parents", map[string]any{ + "summary_id": sum.SummaryID, + "error": err.Error(), + }) + } + var parentIDs []string + for _, ps := range parentSummaries { + parentIDs = append(parentIDs, ps.SummaryID) + } + summaryParts = append(summaryParts, FormatSummaryXML(&sum, parentIDs)) + } + summary := strings.Join(summaryParts, "\n\n") + if systemPromptAddition != "" { + if summary != "" { + summary += "\n\n" + } + summary += systemPromptAddition + } + + return &AssembleResult{ + Messages: messages, + Summary: summary, + }, nil +} + +// resolveItem loads the full message or summary for a context item. +func (a *Assembler) resolveItem(ctx context.Context, item ContextItem) (resolvedItem, error) { + if item.ItemType == "message" { + msg, err := a.store.GetMessageByID(ctx, item.MessageID) + if err != nil { + return resolvedItem{}, err + } + tokens := item.TokenCount + if tokens == 0 { + tokens = msg.TokenCount + } + return resolvedItem{ + ordinal: item.Ordinal, + itemType: "message", + message: msg, + tokenCount: tokens, + }, nil + } + + if item.ItemType == "summary" { + sum, err := a.store.GetSummary(ctx, item.SummaryID) + if err != nil { + return resolvedItem{}, err + } + tokens := item.TokenCount + if tokens == 0 { + tokens = sum.TokenCount + } + return resolvedItem{ + ordinal: item.Ordinal, + itemType: "summary", + summary: sum, + tokenCount: tokens, + }, nil + } + + return resolvedItem{ + ordinal: item.Ordinal, + itemType: item.ItemType, + tokenCount: item.TokenCount, + }, nil +} + +// FormatSummaryXML formats a summary as XML for LLM context. +// This is exported so context managers can format summaries consistently. +func FormatSummaryXML(s *Summary, parentIDs []string) string { + // Build time attributes if available + var attrs string + if s.EarliestAt != nil { + attrs += fmt.Sprintf(` earliest_at="%s"`, s.EarliestAt.Format(time.RFC3339)) + } + if s.LatestAt != nil { + attrs += fmt.Sprintf(` latest_at="%s"`, s.LatestAt.Format(time.RFC3339)) + } + + var parentsSection string + if s.Kind == SummaryKindCondensed && len(parentIDs) > 0 { + parents := "\n" + for _, pid := range parentIDs { + parents += fmt.Sprintf(" \n", pid) + } + parents += " \n" + parentsSection = parents + } + return fmt.Sprintf( + "\n \n %s\n \n%s", + s.SummaryID, + string(s.Kind), + s.Depth, + s.DescendantCount, + attrs, + escapeXML(s.Content), + parentsSection, + ) +} diff --git a/pkg/seahorse/short_assembler_test.go b/pkg/seahorse/short_assembler_test.go new file mode 100644 index 000000000..88a05e64c --- /dev/null +++ b/pkg/seahorse/short_assembler_test.go @@ -0,0 +1,536 @@ +package seahorse + +import ( + "context" + "strings" + "testing" + "time" +) + +// --- Assembler Tests --- + +// helper: create a store with messages and summaries for assembly tests +func setupAssemblerStore(t *testing.T) (*Store, int64) { + t.Helper() + s := openTestStore(t) + ctx := context.Background() + + conv, err := s.GetOrCreateConversation(ctx, "test:assemble") + if err != nil { + t.Fatalf("create conversation: %v", err) + } + + return s, conv.ConversationID +} + +func TestAssemblerAssembleEmpty(t *testing.T) { + s, convID := setupAssemblerStore(t) + ctx := context.Background() + + a := &Assembler{store: s, config: Config{}} + result, err := a.Assemble(ctx, convID, AssembleInput{Budget: 1000}) + if err != nil { + t.Fatalf("Assemble: %v", err) + } + if len(result.Messages) != 0 { + t.Errorf("Messages = %d, want 0", len(result.Messages)) + } + if result.Summary != "" { + t.Errorf("Summary = %q, want empty", result.Summary) + } +} + +func TestAssemblerAssembleMessagesOnly(t *testing.T) { + s, convID := setupAssemblerStore(t) + ctx := context.Background() + + // Create messages + msg1, _ := s.AddMessage(ctx, convID, "user", "hello", 5) + msg2, _ := s.AddMessage(ctx, convID, "assistant", "world", 5) + + // Create context items + s.UpsertContextItems(ctx, convID, []ContextItem{ + {Ordinal: 100, ItemType: "message", MessageID: msg1.ID, TokenCount: 5}, + {Ordinal: 200, ItemType: "message", MessageID: msg2.ID, TokenCount: 5}, + }) + + a := &Assembler{store: s, config: Config{}} + result, err := a.Assemble(ctx, convID, AssembleInput{Budget: 100}) + if err != nil { + t.Fatalf("Assemble: %v", err) + } + + if len(result.Messages) != 2 { + t.Fatalf("Messages = %d, want 2", len(result.Messages)) + } + if result.Messages[0].Content != "hello" { + t.Errorf("Messages[0].Content = %q, want 'hello'", result.Messages[0].Content) + } + if result.Messages[1].Content != "world" { + t.Errorf("Messages[1].Content = %q, want 'world'", result.Messages[1].Content) + } + // No summaries, so Summary should be empty + if result.Summary != "" { + t.Errorf("Summary = %q, want empty", result.Summary) + } +} + +func TestAssemblerAssembleWithSummary(t *testing.T) { + s, convID := setupAssemblerStore(t) + ctx := context.Background() + + // Create a summary + summary, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "summary of early messages", + TokenCount: 50, + }) + + // Create recent messages + msg1, _ := s.AddMessage(ctx, convID, "user", "recent", 5) + msg2, _ := s.AddMessage(ctx, convID, "assistant", "reply", 5) + + // Context: summary + recent messages + s.UpsertContextItems(ctx, convID, []ContextItem{ + {Ordinal: 100, ItemType: "summary", SummaryID: summary.SummaryID, TokenCount: 50}, + {Ordinal: 200, ItemType: "message", MessageID: msg1.ID, TokenCount: 5}, + {Ordinal: 300, ItemType: "message", MessageID: msg2.ID, TokenCount: 5}, + }) + + a := &Assembler{store: s, config: Config{}} + result, err := a.Assemble(ctx, convID, AssembleInput{Budget: 1000}) + if err != nil { + t.Fatalf("Assemble: %v", err) + } + + // Messages = 2 raw messages (summaries are in Summary field, not Messages) + if len(result.Messages) != 2 { + t.Errorf("Messages = %d, want 2 (raw messages only)", len(result.Messages)) + } + // Summary should contain XML with summary content + if result.Summary == "" { + t.Error("Summary should not be empty when summary exists") + } + if !strings.Contains(result.Summary, summary.Content) { + t.Errorf("Summary should contain summary content %q", summary.Content) + } + if !strings.Contains(result.Summary, "`, + TokenCount: 20, + }) + + s.UpsertContextItems(ctx, convID, []ContextItem{ + {Ordinal: 100, ItemType: "summary", SummaryID: summary.SummaryID, TokenCount: 20}, + }) + + a := &Assembler{store: s, config: Config{}} + result, err := a.Assemble(ctx, convID, AssembleInput{Budget: 1000}) + if err != nil { + t.Fatalf("Assemble: %v", err) + } + + // Summary field should contain XML with escaped special characters + if result.Summary == "" { + t.Fatal("Summary should not be empty") + } + + // Check that special characters are escaped + if strings.Contains(result.Summary, "") { + t.Errorf("BUG: unescaped < in summary content: %q", result.Summary) + } + if strings.Contains(result.Summary, `"hello"`) { + t.Errorf("BUG: unescaped \" in summary content: %q", result.Summary) + } + // & should be escaped as & + if strings.Contains(result.Summary, " & ") { + t.Errorf("BUG: unescaped & in summary content: %q", result.Summary) + } +} + +func TestAssemblerSummaryXMLWithParents(t *testing.T) { + s, convID := setupAssemblerStore(t) + ctx := context.Background() + + // Create a leaf and a condensed summary (condensed has parent) + leaf, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "leaf content", + TokenCount: 20, + }) + condensed, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindCondensed, + Depth: 1, + Content: "condensed content", + TokenCount: 15, + ParentIDs: []string{leaf.SummaryID}, + }) + + msg, _ := s.AddMessage(ctx, convID, "user", "fresh", 5) + + s.UpsertContextItems(ctx, convID, []ContextItem{ + {Ordinal: 100, ItemType: "summary", SummaryID: condensed.SummaryID, TokenCount: 15}, + {Ordinal: 200, ItemType: "message", MessageID: msg.ID, TokenCount: 5}, + }) + + a := &Assembler{store: s, config: Config{}} + result, err := a.Assemble(ctx, convID, AssembleInput{Budget: 1000}) + if err != nil { + t.Fatalf("Assemble: %v", err) + } + + // Summary field should contain XML with parent information + if result.Summary == "" { + t.Fatal("Summary should not be empty") + } + xmlContent := result.Summary + + // Should contain section with parent ID + if !contains(xmlContent, "") { + t.Errorf("condensed summary XML missing section: %q", xmlContent) + } + if !contains(xmlContent, leaf.SummaryID) { + t.Errorf("condensed summary XML missing parent ID %q: %q", leaf.SummaryID, xmlContent) + } + + // Should contain kind="condensed" + if !contains(xmlContent, `kind="condensed"`) { + t.Errorf("condensed summary XML missing kind attribute: %q", xmlContent) + } +} + +func TestAssemblerSummaryXMLIncludesDescendantCount(t *testing.T) { + s, convID := setupAssemblerStore(t) + ctx := context.Background() + + // Create a leaf summary with specific descendant count + leaf, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "leaf content", + TokenCount: 20, + DescendantCount: 8, + DescendantTokenCount: 1200, + }) + + msg, _ := s.AddMessage(ctx, convID, "user", "fresh", 5) + + s.UpsertContextItems(ctx, convID, []ContextItem{ + {Ordinal: 100, ItemType: "summary", SummaryID: leaf.SummaryID, TokenCount: 20}, + {Ordinal: 200, ItemType: "message", MessageID: msg.ID, TokenCount: 5}, + }) + + a := &Assembler{store: s, config: Config{}} + result, err := a.Assemble(ctx, convID, AssembleInput{Budget: 1000}) + if err != nil { + t.Fatalf("Assemble: %v", err) + } + + if result.Summary == "" { + t.Fatal("Summary should not be empty") + } + xmlContent := result.Summary + + // Should contain descendant_count="8" + if !contains(xmlContent, `descendant_count="8"`) { + t.Errorf("summary XML missing descendant_count attribute: %q", xmlContent) + } +} + +func TestAssemblerLeafSummaryNoParents(t *testing.T) { + s, convID := setupAssemblerStore(t) + ctx := context.Background() + + // Leaf summary has no parents + leaf, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "leaf content", + TokenCount: 20, + }) + + msg, _ := s.AddMessage(ctx, convID, "user", "fresh", 5) + + s.UpsertContextItems(ctx, convID, []ContextItem{ + {Ordinal: 100, ItemType: "summary", SummaryID: leaf.SummaryID, TokenCount: 20}, + {Ordinal: 200, ItemType: "message", MessageID: msg.ID, TokenCount: 5}, + }) + + a := &Assembler{store: s, config: Config{}} + result, err := a.Assemble(ctx, convID, AssembleInput{Budget: 1000}) + if err != nil { + t.Fatalf("Assemble: %v", err) + } + + if result.Summary == "" { + t.Fatal("Summary should not be empty") + } + xmlContent := result.Summary + + // Leaf summary should NOT have section + if contains(xmlContent, "") { + t.Errorf("leaf summary XML should not have section: %q", xmlContent) + } +} + +func TestAssemblerDepthAwarePrompt(t *testing.T) { + s, convID := setupAssemblerStore(t) + ctx := context.Background() + + // Create a condensed summary (depth >= 2) to trigger full guidance + now := time.Now().UTC() + leaf, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "leaf summary", + TokenCount: 20, + EarliestAt: &now, + LatestAt: &now, + }) + condensed, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindCondensed, + Depth: 2, + Content: "condensed summary", + TokenCount: 15, + ParentIDs: []string{leaf.SummaryID}, + DescendantCount: 1, + DescendantTokenCount: 20, + }) + + msg, _ := s.AddMessage(ctx, convID, "user", "fresh", 5) + + s.UpsertContextItems(ctx, convID, []ContextItem{ + {Ordinal: 100, ItemType: "summary", SummaryID: condensed.SummaryID, TokenCount: 15}, + {Ordinal: 200, ItemType: "message", MessageID: msg.ID, TokenCount: 5}, + }) + + a := &Assembler{store: s, config: Config{}} + result, err := a.Assemble(ctx, convID, AssembleInput{Budget: 1000}) + if err != nil { + t.Fatalf("Assemble: %v", err) + } + + // Should have a depth-aware prompt in Summary field + if result.Summary == "" { + t.Error("expected non-empty Summary when depth >= 2") + } + // SystemPromptAddition is embedded in Summary field + if !strings.Contains(result.Summary, "multi-level summarization") { + t.Error("Summary should contain system prompt addition about multi-level summarization") + } +} + +func TestFormatSummaryXMLUsesSummaryRef(t *testing.T) { + // Spec: condensed summaries use not parentId + now := time.Now().UTC() + s := Summary{ + SummaryID: "sum_condensed1", + Kind: SummaryKindCondensed, + Depth: 1, + Content: "condensed content", + TokenCount: 50, + DescendantCount: 2, + EarliestAt: &now, + LatestAt: &now, + } + parentIDs := []string{"sum_leaf1", "sum_leaf2"} + + xml := FormatSummaryXML(&s, parentIDs) + + // Must use per spec + if !contains(xml, ``) { + t.Errorf("expected , got: %s", xml) + } + if !contains(xml, ``) { + t.Errorf("expected , got: %s", xml) + } + // Must NOT use old tag + if contains(xml, "") { + t.Errorf("should not use tag, got: %s", xml) + } +} + +func TestFormatSummaryXMLIncludesTimestamps(t *testing.T) { + // Spec: summary XML includes earliest_at and latest_at attributes + earliest := time.Date(2026, 3, 15, 10, 0, 0, 0, time.UTC) + latest := time.Date(2026, 3, 15, 14, 30, 0, 0, time.UTC) + s := Summary{ + SummaryID: "sum_leaf1", + Kind: SummaryKindLeaf, + Depth: 0, + Content: "leaf content", + TokenCount: 30, + DescendantCount: 0, + EarliestAt: &earliest, + LatestAt: &latest, + } + + xml := FormatSummaryXML(&s, nil) + + if !contains(xml, `earliest_at="2026-03-15T10:00:00Z"`) { + t.Errorf("missing earliest_at attribute, got: %s", xml) + } + if !contains(xml, `latest_at="2026-03-15T14:30:00Z"`) { + t.Errorf("missing latest_at attribute, got: %s", xml) + } +} + +func TestFormatSummaryXMLNoTimestampsWhenNil(t *testing.T) { + // When EarliestAt/LatestAt are nil, attributes should be omitted + s := Summary{ + SummaryID: "sum_leaf1", + Kind: SummaryKindLeaf, + Depth: 0, + Content: "leaf content", + TokenCount: 30, + DescendantCount: 0, + } + + xml := FormatSummaryXML(&s, nil) + + if contains(xml, "earliest_at=") { + t.Errorf("should not have earliest_at when nil, got: %s", xml) + } + if contains(xml, "latest_at=") { + t.Errorf("should not have latest_at when nil, got: %s", xml) + } +} diff --git a/pkg/seahorse/short_bench_test.go b/pkg/seahorse/short_bench_test.go new file mode 100644 index 000000000..b7e47bcff --- /dev/null +++ b/pkg/seahorse/short_bench_test.go @@ -0,0 +1,336 @@ +package seahorse + +import ( + "context" + "database/sql" + "fmt" + "testing" + "time" + + _ "modernc.org/sqlite" +) + +// newBenchStore creates a test store for benchmarks. +func newBenchStore(b *testing.B) (*Store, func()) { + b.Helper() + db, err := sql.Open("sqlite", ":memory:") + if err != nil { + b.Fatalf("open test db: %v", err) + } + if err := runSchema(db); err != nil { + db.Close() + b.Fatalf("migration: %v", err) + } + return &Store{db: db}, func() { db.Close() } +} + +// --- Ingest benchmarks --- + +func BenchmarkIngest_SingleMessage(b *testing.B) { + s, cleanup := newBenchStore(b) + defer cleanup() + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "bench:ingest") + convID := conv.ConversationID + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := s.AddMessage(ctx, convID, "user", "Test message content", 15) + if err != nil { + b.Fatal(err) + } + } +} + +func BenchmarkIngest_BatchMessages(b *testing.B) { + s, cleanup := newBenchStore(b) + defer cleanup() + ctx := context.Background() + + b.ResetTimer() + for i := 0; i < b.N; i++ { + conv, _ := s.GetOrCreateConversation(ctx, fmt.Sprintf("bench:ingest-batch:%d", i)) + convID := conv.ConversationID + + for j := 0; j < 10; j++ { + added, err := s.AddMessage(ctx, convID, "user", + fmt.Sprintf("Message %d in batch", j), 10) + if err != nil { + b.Fatal(err) + } + s.AppendContextMessage(ctx, convID, added.ID) + } + } +} + +// --- Assemble benchmarks --- + +func BenchmarkAssemble_MessagesOnly(b *testing.B) { + s, cleanup := newBenchStore(b) + defer cleanup() + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "bench:assemble-msgs") + convID := conv.ConversationID + + // Add 100 messages + for i := 0; i < 100; i++ { + m, _ := s.AddMessage(ctx, convID, "user", + fmt.Sprintf("Message content %d with some text", i), 10) + s.AppendContextMessage(ctx, convID, m.ID) + } + + a := &Assembler{store: s} + input := AssembleInput{Budget: 50000} + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := a.Assemble(ctx, convID, input) + if err != nil { + b.Fatal(err) + } + } +} + +func BenchmarkAssemble_WithSummaries(b *testing.B) { + s, cleanup := newBenchStore(b) + defer cleanup() + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "bench:assemble-sums") + convID := conv.ConversationID + + now := time.Now().UTC() + + // Add 10 leaf summaries + for i := 0; i < 10; i++ { + sum, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: fmt.Sprintf("Leaf summary %d", i), + TokenCount: 500, + EarliestAt: &now, + LatestAt: &now, + }) + s.AppendContextSummary(ctx, convID, sum.SummaryID) + } + + // Add 20 fresh messages + for i := 0; i < 20; i++ { + m, _ := s.AddMessage(ctx, convID, "user", fmt.Sprintf("Fresh message %d", i), 10) + s.AppendContextMessage(ctx, convID, m.ID) + } + + a := &Assembler{store: s} + input := AssembleInput{Budget: 10000} + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := a.Assemble(ctx, convID, input) + if err != nil { + b.Fatal(err) + } + } +} + +func BenchmarkAssemble_BudgetEviction(b *testing.B) { + s, cleanup := newBenchStore(b) + defer cleanup() + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "bench:assemble-evict") + convID := conv.ConversationID + + now := time.Now().UTC() + + // Add 50 leaf summaries (more than budget can hold) + for i := 0; i < 50; i++ { + sum, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: fmt.Sprintf("Summary %d", i), + TokenCount: 300, + EarliestAt: &now, + LatestAt: &now, + }) + s.AppendContextSummary(ctx, convID, sum.SummaryID) + } + + // Add fresh tail + for i := 0; i < FreshTailCount; i++ { + m, _ := s.AddMessage(ctx, convID, "user", "fresh", 10) + s.AppendContextMessage(ctx, convID, m.ID) + } + + a := &Assembler{store: s} + input := AssembleInput{Budget: 5000} // Force eviction + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := a.Assemble(ctx, convID, input) + if err != nil { + b.Fatal(err) + } + } +} + +// --- Search (FTS5) benchmarks --- + +// benchSeedSummaries adds n summaries to a conversation for search benchmarks. +func benchSeedSummaries(b *testing.B, s *Store, convID int64, n int, contentTpl string) { + b.Helper() + now := time.Now().UTC() + for i := 0; i < n; i++ { + sum, err := s.CreateSummary(context.Background(), CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: fmt.Sprintf(contentTpl, i), + TokenCount: 200, + EarliestAt: &now, + LatestAt: &now, + }) + if err != nil { + b.Fatalf("create summary: %v", err) + } + s.AppendContextSummary(context.Background(), convID, sum.SummaryID) + } +} + +func BenchmarkSearchSummaries_FTS5(b *testing.B) { + s, cleanup := newBenchStore(b) + defer cleanup() + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "bench:search-fts") + convID := conv.ConversationID + + benchSeedSummaries(b, s, convID, 100, "Summary about database configuration and API endpoints %d") + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := s.SearchSummaries(ctx, SearchInput{ + Pattern: "database", + Mode: "full_text", + ConversationID: convID, + }) + if err != nil { + b.Fatal(err) + } + } +} + +func BenchmarkSearchSummaries_Like(b *testing.B) { + s, cleanup := newBenchStore(b) + defer cleanup() + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "bench:search-like") + convID := conv.ConversationID + + benchSeedSummaries(b, s, convID, 100, "Summary about configuration %d") + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := s.SearchSummaries(ctx, SearchInput{ + Pattern: "config", + Mode: "like", + ConversationID: convID, + }) + if err != nil { + b.Fatal(err) + } + } +} + +func BenchmarkSearchMessages_FTS5(b *testing.B) { + s, cleanup := newBenchStore(b) + defer cleanup() + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "bench:search-msg-fts") + convID := conv.ConversationID + + // Add 500 messages + for i := 0; i < 500; i++ { + m, _ := s.AddMessage(ctx, convID, "user", + fmt.Sprintf("User message about API and database integration %d", i), 20) + s.AppendContextMessage(ctx, convID, m.ID) + } + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := s.SearchMessages(ctx, SearchInput{ + Pattern: "API database", + Mode: "full_text", + ConversationID: convID, + }) + if err != nil { + b.Fatal(err) + } + } +} + +// --- Bootstrap benchmarks --- + +func BenchmarkBootstrap_Empty(b *testing.B) { + s, cleanup := newBenchStore(b) + defer cleanup() + ctx := context.Background() + + b.ResetTimer() + for i := 0; i < b.N; i++ { + conv, _ := s.GetOrCreateConversation(ctx, fmt.Sprintf("bench:bootstrap-empty:%d", i)) + convID := conv.ConversationID + _ = convID // Bootstrap with empty history + } +} + +func BenchmarkBootstrap_100Messages(b *testing.B) { + s, cleanup := newBenchStore(b) + defer cleanup() + ctx := context.Background() + + // Prepare 100 messages + msgs := make([]Message, 100) + for i := 0; i < 100; i++ { + msgs[i] = Message{ + Role: "user", + Content: fmt.Sprintf("Bootstrap message %d", i), + TokenCount: 15, + } + } + + b.ResetTimer() + for i := 0; i < b.N; i++ { + conv, _ := s.GetOrCreateConversation(ctx, fmt.Sprintf("bench:bootstrap-100:%d", i)) + convID := conv.ConversationID + + for _, m := range msgs { + added, _ := s.AddMessage(ctx, convID, m.Role, m.Content, m.TokenCount) + s.AppendContextMessage(ctx, convID, added.ID) + } + } +} + +func BenchmarkBootstrap_500Messages(b *testing.B) { + s, cleanup := newBenchStore(b) + defer cleanup() + ctx := context.Background() + + msgs := make([]Message, 500) + for i := 0; i < 500; i++ { + msgs[i] = Message{ + Role: "user", + Content: fmt.Sprintf("Bootstrap message %d", i), + TokenCount: 15, + } + } + + b.ResetTimer() + for i := 0; i < b.N; i++ { + conv, _ := s.GetOrCreateConversation(ctx, fmt.Sprintf("bench:bootstrap-500:%d", i)) + convID := conv.ConversationID + + for _, m := range msgs { + added, _ := s.AddMessage(ctx, convID, m.Role, m.Content, m.TokenCount) + s.AppendContextMessage(ctx, convID, added.ID) + } + } +} diff --git a/pkg/seahorse/short_compaction.go b/pkg/seahorse/short_compaction.go new file mode 100644 index 000000000..30e290926 --- /dev/null +++ b/pkg/seahorse/short_compaction.go @@ -0,0 +1,898 @@ +package seahorse + +import ( + "context" + "fmt" + "sort" + "time" + + "github.com/sipeed/picoclaw/pkg/logger" + "github.com/sipeed/picoclaw/pkg/providers" + "github.com/sipeed/picoclaw/pkg/tokenizer" +) + +// CompactInput controls compaction behavior. +type CompactInput struct { + Budget *int // Token budget override + Force bool // Force compaction even if below threshold +} + +// CompactResult describes what was compacted. +type CompactResult struct { + SummariesCreated []string `json:"summariesCreated"` + TokensSaved int `json:"tokensSaved"` + LeafSummaries int `json:"leafSummaries"` + CondensedSummaries int `json:"condensedSummaries"` +} + +// NeedsCompaction returns true if context tokens >= ContextThreshold × contextWindow. +func (e *CompactionEngine) NeedsCompaction(ctx context.Context, convID int64, contextWindow int) (bool, error) { + tokens, err := e.store.GetContextTokenCount(ctx, convID) + if err != nil { + return false, fmt.Errorf("get token count: %w", err) + } + threshold := int(float64(contextWindow) * ContextThreshold) + return tokens >= threshold, nil +} + +// Close cancels the shutdown context, stopping async goroutines. +func (e *CompactionEngine) Close() { + if e.shutdownCancel != nil { + e.shutdownCancel() + } +} + +// Compact runs leaf compaction (sync) and optionally condensed compaction. +func (e *CompactionEngine) Compact(ctx context.Context, convID int64, input CompactInput) (*CompactResult, error) { + result := &CompactResult{} + + // Phase 1: leaf compaction (synchronous, every turn) + summaryID, err := e.compactLeaf(ctx, convID) + if err != nil { + return nil, fmt.Errorf("compact leaf: %w", err) + } + if summaryID != nil { + result.SummariesCreated = append(result.SummariesCreated, *summaryID) + result.LeafSummaries++ + logger.InfoCF("seahorse", "compact: leaf", map[string]any{ + "conv_id": convID, + "summary_id": *summaryID, + }) + } + + // Phase 2: condensed compaction if over threshold + tokensBefore, _ := e.store.GetContextTokenCount(ctx, convID) + var budget int + if input.Budget != nil { + budget = *input.Budget + if budget == 0 { + logger.ErrorCF("seahorse", "Compact: budget is 0, this should not happen", map[string]any{ + "conv_id": convID, + }) + } + } else { + budget = int(float64(tokensBefore) * ContextThreshold) + } + + if input.Force || (tokensBefore > budget && budget > 0) { + // Launch async condensed compaction with dedup + if _, loaded := e.condensing.LoadOrStore(convID, struct{}{}); !loaded { + go func() { + defer e.condensing.Delete(convID) + e.runCondensedLoop(e.shutdownCtx, convID) + }() + } + } + + tokensAfter, _ := e.store.GetContextTokenCount(ctx, convID) + if tokensAfter < tokensBefore { + result.TokensSaved = tokensBefore - tokensAfter + } + + return result, nil +} + +// CompactUntilUnder aggressively compacts until context is under budget. +func (e *CompactionEngine) CompactUntilUnder(ctx context.Context, convID int64, budget int) (*CompactResult, error) { + result := &CompactResult{} + prevTokens := 0 + logger.InfoCF("seahorse", "compact_until_under: start", map[string]any{"conv_id": convID, "budget": budget}) + + for iter := 0; iter < MaxCompactIterations; iter++ { + tokens, err := e.store.GetContextTokenCount(ctx, convID) + if err != nil { + return result, fmt.Errorf("get tokens: %w", err) + } + if tokens <= budget { + logger.InfoCF("seahorse", "compact_until_under: done", map[string]any{ + "conv_id": convID, + "budget": budget, + "tokens": tokens, + "leaf": result.LeafSummaries, + "condensed": result.CondensedSummaries, + }) + return result, nil + } + + // Try leaf first + summaryID, err := e.compactLeaf(ctx, convID, true) + if err != nil { + return result, err + } + if summaryID != nil { + result.SummariesCreated = append(result.SummariesCreated, *summaryID) + result.LeafSummaries++ + logger.InfoCF("seahorse", "compact_until_under: leaf", map[string]any{ + "conv_id": convID, + "summary_id": *summaryID, + }) + continue + } + + // Try condensed with forced fanout + condensedID, err := e.compactCondensed(ctx, convID) + if err != nil { + return result, err + } + if condensedID != nil { + result.SummariesCreated = append(result.SummariesCreated, *condensedID) + result.CondensedSummaries++ + logger.InfoCF("seahorse", "compact_until_under: condensed", map[string]any{ + "conv_id": convID, + "summary_id": *condensedID, + }) + continue + } + + // No progress + newTokens, _ := e.store.GetContextTokenCount(ctx, convID) + if newTokens >= prevTokens { + logger.WarnCF("seahorse", "compact_until_under: no progress", map[string]any{ + "conv_id": convID, + "tokens": newTokens, + }) + return result, nil + } + prevTokens = newTokens + } + + // Safety cap exceeded — see MaxCompactIterations doc for rationale. + logger.WarnCF("seahorse", "compact_until_under: exceeded max iterations", map[string]any{ + "conv_id": convID, + "budget": budget, + "iterations": MaxCompactIterations, + "tokens": prevTokens, + }) + return result, nil +} + +// compactLeaf compresses the oldest contiguous message chunk into a leaf summary. +// When force is true, FreshTailCount protection is bypassed (used by CompactUntilUnder). +func (e *CompactionEngine) compactLeaf(ctx context.Context, convID int64, force ...bool) (*string, error) { + items, err := e.store.GetContextItems(ctx, convID) + if err != nil { + return nil, err + } + + // Find oldest contiguous message chunk outside fresh tail + msgCount := 0 + msgTokens := 0 + for _, item := range items { + if item.ItemType == "message" { + msgCount++ + msgTokens += item.TokenCount + } + } + + // Trigger if either message count or token threshold is met + if msgCount < LeafMinFanout && msgTokens < LeafChunkTokens { + return nil, nil + } + + // Calculate fresh tail boundary (bypass when forced) + useForce := len(force) > 0 && force[0] + tailStartIdx := len(items) - FreshTailCount + if useForce { + tailStartIdx = len(items) // allow compacting everything + } + if tailStartIdx < 0 { + tailStartIdx = 0 + } + + // Find oldest contiguous message chunk, accumulating up to LeafChunkTokens + var chunk []ContextItem + chunkStart := -1 + chunkEnd := -1 + accumTokens := 0 + for i := 0; i < tailStartIdx; i++ { + if items[i].ItemType == "message" { + if chunkStart == -1 { + chunkStart = i + } + chunkEnd = i + accumTokens += items[i].TokenCount + // Stop accumulating once we reach the token budget + if accumTokens >= LeafChunkTokens { + break + } + } else { + // Non-message breaks the chunk + if chunkStart != -1 && (chunkEnd-chunkStart+1) >= LeafMinFanout { + break + } + chunkStart = -1 + chunkEnd = -1 + accumTokens = 0 + } + } + + if chunkStart == -1 || (chunkEnd-chunkStart+1) < LeafMinFanout { + return nil, nil + } + + chunk = items[chunkStart : chunkEnd+1] + + // Collect messages for the chunk + var messages []Message + for _, item := range chunk { + msg, innerErr := e.store.GetMessageByID(ctx, item.MessageID) + if innerErr != nil { + return nil, innerErr + } + messages = append(messages, *msg) + } + + // Get prior summaries for context + priorSummary := "" + priorCount := 0 + for i := chunkStart - 1; i >= 0 && priorCount < 2; i-- { + if items[i].ItemType == "summary" { + sum, innerErr2 := e.store.GetSummary(ctx, items[i].SummaryID) + if innerErr2 == nil { + priorSummary = sum.Content + "\n" + priorSummary + priorCount++ + } + } + } + + // Generate summary + content, err := e.generateLeafSummary(ctx, messages, priorSummary) + if err != nil { + return nil, err + } + + // Create summary in store + tokenCount := tokenizer.EstimateMessageTokens(providers.Message{Content: content}) + + var earliestAt, latestAt *time.Time + if len(messages) > 0 { + earliestAt = &messages[0].CreatedAt + latestAt = &messages[len(messages)-1].CreatedAt + } + + summary, err := e.store.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: content, + TokenCount: tokenCount, + EarliestAt: earliestAt, + LatestAt: latestAt, + SourceMessageTokens: sumMessageTokens(messages), + }) + if err != nil { + return nil, err + } + + // Link to source messages + msgIDs := make([]int64, len(messages)) + for i, m := range messages { + msgIDs[i] = m.ID + } + if err := e.store.LinkSummaryToMessages(ctx, summary.SummaryID, msgIDs); err != nil { + return nil, err + } + + // Replace context range with summary + if err := e.store.ReplaceContextRangeWithSummary( + ctx, convID, chunk[0].Ordinal, chunk[len(chunk)-1].Ordinal, summary.SummaryID, + ); err != nil { + return nil, err + } + + return &summary.SummaryID, nil +} + +// compactCondensed compresses multiple summaries into one higher-level summary. +func (e *CompactionEngine) compactCondensed(ctx context.Context, convID int64) (*string, error) { + // Try ordinal-aware selection first (respects consecutive ordering) + var candidates []Summary + + depths, err := e.store.GetDistinctDepthsInContext(ctx, convID, 0) + if err != nil { + return nil, err + } + for _, depth := range depths { + var chunkAtDepth []Summary + var err2 error + chunkAtDepth, err2 = e.selectOldestChunkAtDepth(ctx, convID, depth) + if err2 != nil { + continue + } + if len(chunkAtDepth) > 0 { + candidates = chunkAtDepth + break + } + } + + // Fallback to depth-grouping selection + if len(candidates) == 0 { + candidates, err = e.selectShallowestCondensationCandidate(ctx, convID, false) + if err != nil { + return nil, err + } + } + if len(candidates) == 0 { + return nil, nil + } + + // Generate condensed summary + content, err := e.generateCondensedSummary(ctx, candidates) + if err != nil { + return nil, err + } + + // Merge metadata + maxDepth := 0 + descendantCount := 0 + descendantTokenCount := 0 + sourceMessageTokens := 0 + var earliestAt, latestAt *time.Time + + parentIDs := make([]string, len(candidates)) + for i, c := range candidates { + parentIDs[i] = c.SummaryID + if c.Depth > maxDepth { + maxDepth = c.Depth + } + descendantCount += c.DescendantCount + 1 + descendantTokenCount += c.TokenCount + c.DescendantTokenCount + sourceMessageTokens += c.SourceMessageTokenCount + if c.EarliestAt != nil { + if earliestAt == nil || c.EarliestAt.Before(*earliestAt) { + earliestAt = c.EarliestAt + } + } + if c.LatestAt != nil { + if latestAt == nil || c.LatestAt.After(*latestAt) { + latestAt = c.LatestAt + } + } + } + + tokenCount := tokenizer.EstimateMessageTokens(providers.Message{Content: content}) + + summary, err := e.store.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindCondensed, + Depth: maxDepth + 1, + Content: content, + TokenCount: tokenCount, + EarliestAt: earliestAt, + LatestAt: latestAt, + DescendantCount: descendantCount, + DescendantTokenCount: descendantTokenCount, + SourceMessageTokens: sourceMessageTokens, + ParentIDs: parentIDs, + }) + if err != nil { + return nil, err + } + + // Find the ordinal range for the candidate summaries in context + items, err := e.store.GetContextItems(ctx, convID) + if err != nil { + return nil, err + } + + candidateSet := make(map[string]bool) + for _, c := range candidates { + candidateSet[c.SummaryID] = true + } + + startOrd := -1 + endOrd := -1 + hasNonCandidate := false + for _, item := range items { + if item.ItemType == "summary" && candidateSet[item.SummaryID] { + if startOrd == -1 { + startOrd, endOrd = item.Ordinal, item.Ordinal + } else { + // Check for non-candidate items between endOrd and current ordinal + for _, it := range items { + if it.Ordinal > endOrd && it.Ordinal <= item.Ordinal { + if it.ItemType != "summary" || !candidateSet[it.SummaryID] { + hasNonCandidate = true + break + } + } + } + if hasNonCandidate { + break + } + if item.Ordinal < startOrd { + startOrd = item.Ordinal + } + if item.Ordinal > endOrd { + endOrd = item.Ordinal + } + } + } + } + + if startOrd == -1 || endOrd == -1 { + return nil, nil + } + + // Collect candidate summary IDs + candidateIDs := make([]string, 0, len(candidates)) + for _, c := range candidates { + candidateIDs = append(candidateIDs, c.SummaryID) + } + + if hasNonCandidate { + // Use safe per-item deletion to avoid deleting non-candidate items + if err := e.store.ReplaceContextItemsWithSummary(ctx, convID, candidateIDs, summary.SummaryID); err != nil { + return nil, err + } + } else { + // Candidates are consecutive, use efficient range deletion + if err := e.store.ReplaceContextRangeWithSummary(ctx, convID, startOrd, endOrd, summary.SummaryID); err != nil { + return nil, err + } + } + + return &summary.SummaryID, nil +} + +// selectShallowestCondensationCandidate finds the shallowest consecutive summary group. +func (e *CompactionEngine) selectShallowestCondensationCandidate( + ctx context.Context, convID int64, forced bool, +) ([]Summary, error) { + items, err := e.store.GetContextItems(ctx, convID) + if err != nil { + return nil, err + } + + // Group by depth, find consecutive runs + tailStartIdx := len(items) - FreshTailCount + if tailStartIdx < 0 { + tailStartIdx = 0 + } + + minFanout := CondensedMinFanout + if forced { + minFanout = CondensedMinFanoutHard + } + + // Track depth groups + depthGroups := make(map[int][]ContextItem) + for i := 0; i < tailStartIdx; i++ { + item := items[i] + if item.ItemType != "summary" { + continue + } + sum, err := e.store.GetSummary(ctx, item.SummaryID) + if err != nil { + continue + } + depthGroups[sum.Depth] = append(depthGroups[sum.Depth], item) + } + + // Find shallowest depth with enough candidates + // Collect all depths and sort to handle non-consecutive depths + var depths []int + for depth := range depthGroups { + depths = append(depths, depth) + } + sort.Ints(depths) + + for _, depth := range depths { + group := depthGroups[depth] + if len(group) >= minFanout { + // Load summaries + var result []Summary + for _, item := range group[:minFanout] { + sum, err := e.store.GetSummary(ctx, item.SummaryID) + if err != nil { + continue + } + result = append(result, *sum) + } + return result, nil + } + } + + return nil, nil +} + +// selectOldestChunkAtDepth scans context_items from oldest ordinal, collecting consecutive +// summaries at the given depth. Stops at non-summary items, different depth, fresh tail, or +// token overflow. Returns contiguous chunk of summaries. +func (e *CompactionEngine) selectOldestChunkAtDepth( + ctx context.Context, convID int64, targetDepth int, +) ([]Summary, error) { + items, err := e.store.GetContextItems(ctx, convID) + if err != nil { + return nil, err + } + + tailStartIdx := len(items) - FreshTailCount + if tailStartIdx < 0 { + tailStartIdx = 0 + } + + var chunk []Summary + accumTokens := 0 + + for i := 0; i < tailStartIdx; i++ { + item := items[i] + if item.ItemType != "summary" { + // Non-summary breaks the chunk + break + } + sum, err := e.store.GetSummary(ctx, item.SummaryID) + if err != nil { + break + } + if sum.Depth != targetDepth { + // Different depth breaks the chunk + break + } + if accumTokens+sum.TokenCount > LeafChunkTokens { + // Token overflow stops collection + break + } + chunk = append(chunk, *sum) + accumTokens += sum.TokenCount + } + + // Min tokens check: spec line 808 + // chunk tokens must be >= max(CondensedTargetTokens, LeafChunkTokens × 0.1) = 2000 + minTokens := CondensedTargetTokens // 2000 + if accumTokens < minTokens { + return nil, nil + } + + return chunk, nil +} + +// generateLeafSummary calls the LLM to generate a leaf summary with 3-level escalation. +// Level 1: normal LLM prompt. Level 2: aggressive prompt. Level 3: deterministic truncation. +func (e *CompactionEngine) generateLeafSummary( + ctx context.Context, + messages []Message, + previousSummary string, +) (string, error) { + if e.complete == nil { + return truncateSummary(messages), nil + } + + sourceText := formatMessagesForSummary(messages) + inputTokens := sumMessageTokens(messages) + targetTokens := minInt(LeafTargetTokens, int(float64(inputTokens)*0.35)) + + // Level 1: normal prompt + prompt := buildLeafSummaryPrompt(sourceText, previousSummary, targetTokens) + content, err := e.complete(ctx, prompt, CompleteOptions{ + MaxTokens: LeafTargetTokens * 2, + Temperature: 0.3, + }) + if err != nil { + return "", err + } + if content == "" { + // Retry with temperature=0 + content, err = e.complete(ctx, prompt, CompleteOptions{ + MaxTokens: LeafTargetTokens * 2, + Temperature: 0, + }) + if err != nil { + return "", err + } + } + + // Check if level 1 succeeded + if content != "" && tokenizer.EstimateMessageTokens(providers.Message{Content: content}) < inputTokens { + return content, nil + } + + // Level 2: aggressive prompt + aggressiveTarget := minInt(640, int(float64(inputTokens)*0.20)) + aggressivePrompt := buildAggressiveLeafSummaryPrompt(sourceText, previousSummary, aggressiveTarget) + content, err = e.complete(ctx, aggressivePrompt, CompleteOptions{ + MaxTokens: aggressiveTarget * 2, + Temperature: 0.3, + }) + if err != nil { + return "", err + } + if content == "" { + // Retry with temperature=0 + content, err = e.complete(ctx, aggressivePrompt, CompleteOptions{ + MaxTokens: aggressiveTarget * 2, + Temperature: 0, + }) + if err != nil { + return "", err + } + } + if content != "" && tokenizer.EstimateMessageTokens(providers.Message{Content: content}) < inputTokens { + return content, nil + } + + // Level 3: deterministic truncation + return truncateSummary(messages), nil +} + +// generateCondensedSummary calls the LLM to generate a condensed summary with 3-level escalation. +func (e *CompactionEngine) generateCondensedSummary(ctx context.Context, summaries []Summary) (string, error) { + if e.complete == nil { + return truncateCondensedSummaries(summaries), nil + } + + sourceText := formatSummariesForCondensation(summaries) + inputTokens := sumSummaryTokens(summaries) + targetTokens := minInt(CondensedTargetTokens, int(float64(inputTokens)*0.35)) + + // Level 1: normal prompt + prompt := buildCondensedSummaryPrompt(sourceText, targetTokens) + content, err := e.complete(ctx, prompt, CompleteOptions{ + MaxTokens: CondensedTargetTokens * 2, + Temperature: 0.3, + }) + if err != nil { + return "", err + } + if content == "" { + content, err = e.complete(ctx, prompt, CompleteOptions{ + MaxTokens: CondensedTargetTokens * 2, + Temperature: 0, + }) + if err != nil { + return "", err + } + } + if content != "" { + return content, nil + } + + // Level 2: aggressive prompt + aggressiveTarget := minInt(640, int(float64(inputTokens)*0.20)) + aggressivePrompt := buildCondensedSummaryPrompt(sourceText, aggressiveTarget) + content, err = e.complete(ctx, aggressivePrompt, CompleteOptions{ + MaxTokens: aggressiveTarget * 2, + Temperature: 0.3, + }) + if err != nil { + return "", err + } + if content != "" { + return content, nil + } + + // Level 3: deterministic fallback + return truncateCondensedSummaries(summaries), nil +} + +// runCondensedLoop runs condensed compaction in a loop until: +// a) context tokens <= threshold (success), OR +// b) No candidate found (nothing to condense), OR +// c) tokensAfter >= tokensBefore (no progress this iteration), OR +// d) tokensAfter >= previousTokens (no improvement over last iteration) +func (e *CompactionEngine) runCondensedLoop(ctx context.Context, convID int64) { + var prevTokens int + for { + select { + case <-ctx.Done(): + return + default: + } + + tokensBefore, err := e.store.GetContextTokenCount(ctx, convID) + if err != nil { + logger.ErrorCF("seahorse", "condensed: get tokens", map[string]any{"error": err.Error()}) + return + } + + condensedID, err := e.compactCondensed(ctx, convID) + if err != nil { + logger.ErrorCF("seahorse", "condensed: compact", map[string]any{"error": err.Error()}) + return + } + if condensedID == nil { + // No candidate found + logger.DebugCF("seahorse", "condensed: no candidate", map[string]any{"conv_id": convID}) + return + } + + tokensAfter, _ := e.store.GetContextTokenCount(ctx, convID) + + if tokensAfter >= tokensBefore { + // No progress this iteration + logger.DebugCF( + "seahorse", + "condensed: no progress", + map[string]any{"conv_id": convID, "tokens_before": tokensBefore, "tokens_after": tokensAfter}, + ) + return + } + if tokensAfter >= prevTokens && prevTokens > 0 { + // No improvement over last iteration + logger.DebugCF( + "seahorse", + "condensed: no improvement", + map[string]any{"conv_id": convID, "tokens": tokensAfter}, + ) + return + } + + prevTokens = tokensAfter + } +} + +// --- Helper functions --- + +func formatMessagesForSummary(messages []Message) string { + var result string + for _, m := range messages { + ts := m.CreatedAt.Format("2006-01-02 15:04 MST") + content := m.Content + if content == "" && len(m.Parts) > 0 { + content = partsToReadableContent(m.Parts) + } + result += fmt.Sprintf("[%s]\n%s\n\n", ts, content) + } + return result +} + +func formatSummariesForCondensation(summaries []Summary) string { + var result string + for _, s := range summaries { + earliest := "" + if s.EarliestAt != nil { + earliest = s.EarliestAt.Format("2006-01-02") + } + latest := "" + if s.LatestAt != nil { + latest = s.LatestAt.Format("2006-01-02") + } + result += fmt.Sprintf("[%s - %s]\n%s\n\n", earliest, latest, s.Content) + } + return result +} + +func buildLeafSummaryPrompt(sourceText, previousSummary string, targetTokens int) string { + prev := "(none)" + if previousSummary != "" { + prev = previousSummary + } + return fmt.Sprintf(`You summarize a SEGMENT of a conversation for future model turns. +Treat this as incremental memory compaction input, not a full-conversation summary. + +Normal summary policy: +- Preserve key decisions, rationale, constraints, and active tasks. +- Keep essential technical details needed to continue work safely. +- Remove obvious repetition and conversational filler. + +Output requirements: +- Plain text only. +- No preamble, headings, or markdown formatting. +- Track file operations (created, modified, deleted, renamed) with file paths and current status. +- If no file operations appear, include exactly: "Files: none". +- End with exactly: "Expand for details about: ". +- Target length: about %d tokens or less. + + +%s + + + +%s +`, targetTokens, prev, sourceText) +} + +func buildCondensedSummaryPrompt(sourceText string, targetTokens int) string { + return fmt.Sprintf(`You condense multiple summaries into a single higher-level summary. +Preserve all important decisions, constraints, and outcomes. +Merge overlapping topics. Keep technical details intact. + +Output requirements: +- Plain text only. +- No preamble, headings, or markdown formatting. +- End with exactly: "Expand for details about: ". +- Target length: about %d tokens or less. + + +%s +`, targetTokens, sourceText) +} + +func buildAggressiveLeafSummaryPrompt(sourceText, previousSummary string, targetTokens int) string { + prev := "(none)" + if previousSummary != "" { + prev = previousSummary + } + return fmt.Sprintf(`You summarize a SEGMENT of a conversation for future model turns. +Aggressive summary policy: +- Keep only durable facts and current task state. +- Remove examples, repetition, and low-value narrative details. +- Preserve explicit TODOs, blockers, decisions, and constraints. + +Output requirements: +- Plain text only. +- No preamble, headings, or markdown formatting. +- Track file operations (created, modified, deleted, renamed) with file paths and current status. +- If no file operations appear, include exactly: "Files: none". +- End with exactly: "Expand for details about: ". +- Target length: about %d tokens or less. + + +%s + + + +%s +`, targetTokens, prev, sourceText) +} + +func truncateSummary(messages []Message) string { + content := "" + for _, m := range messages { + c := m.Content + if c == "" && len(m.Parts) > 0 { + c = partsToReadableContent(m.Parts) + } + content += c + "\n" + } + if len(content) > 2048 { + content = content[:2048] + } + content += fmt.Sprintf("\n[Truncated from %d messages]", len(messages)) + return content +} + +func truncateCondensedSummaries(summaries []Summary) string { + content := "" + for _, s := range summaries { + content += s.Content + "\n" + } + if len(content) > 2048 { + content = content[:2048] + } + content += fmt.Sprintf("\n[Condensed from %d summaries]", len(summaries)) + return content +} + +func sumMessageTokens(messages []Message) int { + total := 0 + for _, m := range messages { + total += m.TokenCount + } + return total +} + +func sumSummaryTokens(summaries []Summary) int { + total := 0 + for _, s := range summaries { + total += s.TokenCount + } + return total +} + +func minInt(a, b int) int { + if a < b { + return a + } + return b +} diff --git a/pkg/seahorse/short_compaction_test.go b/pkg/seahorse/short_compaction_test.go new file mode 100644 index 000000000..ea7dcb52d --- /dev/null +++ b/pkg/seahorse/short_compaction_test.go @@ -0,0 +1,974 @@ +package seahorse + +import ( + "context" + "fmt" + "sync" + "sync/atomic" + "testing" + "time" +) + +// --- Test Helpers --- + +// waitForCondensed blocks until the async condensed goroutine for convID finishes. +// Returns false if timeout is reached. +func waitForCondensed(ce *CompactionEngine, convID int64, timeout time.Duration) bool { + deadline := time.Now().Add(timeout) + for time.Now().Before(deadline) { + if _, exists := ce.condensing.Load(convID); !exists { + return true + } + time.Sleep(50 * time.Millisecond) + } + return false +} + +// --- Compaction Tests --- + +func newTestCompactionEngine(t *testing.T) (*CompactionEngine, *Store, int64) { + t.Helper() + db := openTestDB(t) + if err := runSchema(db); err != nil { + t.Fatalf("migration: %v", err) + } + s := &Store{db: db} + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "test:compact") + shutdownCtx, shutdownCancel := context.WithCancel(context.Background()) + ce := &CompactionEngine{ + store: s, + config: Config{}, + complete: mockCompleteFn, + shutdownCtx: shutdownCtx, + shutdownCancel: shutdownCancel, + } + convID := conv.ConversationID + // Ensure async goroutines are stopped before database is closed. + // Register cleanup here (after openTestDB) so it runs BEFORE openTestDB's db.Close(). + t.Cleanup(func() { + shutdownCancel() + // Wait for async condensed goroutine to finish (poll condensing map) + deadline := time.Now().Add(2 * time.Second) + for time.Now().Before(deadline) { + if _, exists := ce.condensing.Load(convID); !exists { + break + } + time.Sleep(50 * time.Millisecond) + } + }) + return ce, s, conv.ConversationID +} + +// newTestCompactionEngineWithStore creates a CompactionEngine with existing store. +// Note: Caller is responsible for calling shutdownCancel when test ends. +func newTestCompactionEngineWithStore( + s *Store, complete CompleteFn, +) (ce *CompactionEngine, shutdownCancel context.CancelFunc) { + shutdownCtx, cancel := context.WithCancel(context.Background()) + return &CompactionEngine{ + store: s, + config: Config{}, + complete: complete, + shutdownCtx: shutdownCtx, + shutdownCancel: cancel, + }, cancel +} + +// mockCompleteFn returns a simple summary for testing +var mockCompleteFn CompleteFn = func(ctx context.Context, prompt string, opts CompleteOptions) (string, error) { + return "Mock summary of the conversation segment.", nil +} + +func TestNeedsCompaction(t *testing.T) { + ce, s, convID := newTestCompactionEngine(t) + ctx := context.Background() + + // Empty context — no compaction needed + needed, err := ce.NeedsCompaction(ctx, convID, 10000) + if err != nil { + t.Fatalf("NeedsCompaction: %v", err) + } + if needed { + t.Error("expected no compaction for empty context") + } + + // Add messages to context, total tokens = 8000 + for i := 0; i < 8; i++ { + m, _ := s.AddMessage(ctx, convID, "user", "test message content", 1000) + s.AppendContextMessage(ctx, convID, m.ID) + } + + // Threshold = 0.75 × 10000 = 7500. We have 8000 tokens → needs compaction + needed, err = ce.NeedsCompaction(ctx, convID, 10000) + if err != nil { + t.Fatalf("NeedsCompaction: %v", err) + } + if !needed { + t.Error("expected compaction needed at 8000/10000 tokens (threshold 75%)") + } + + // Below threshold: 5000 / 10000 → no compaction + s.UpsertContextItems(ctx, convID, nil) // clear + for i := 0; i < 5; i++ { + m, _ := s.AddMessage(ctx, convID, "user", "test", 1000) + s.AppendContextMessage(ctx, convID, m.ID) + } + needed, _ = ce.NeedsCompaction(ctx, convID, 10000) + if needed { + t.Error("expected no compaction at 5000/10000 tokens") + } +} + +func TestCompactLeaf(t *testing.T) { + ce, s, convID := newTestCompactionEngine(t) + ctx := context.Background() + + // Create enough messages to trigger leaf compaction: + // Need > FreshTailCount(32) evictable messages with >= LeafMinFanout(8) contiguous + for i := 0; i < 40; i++ { + m, _ := s.AddMessage(ctx, convID, "user", "message content for compaction test", 100) + s.AppendContextMessage(ctx, convID, m.ID) + } + + // Compact + result, err := ce.Compact(ctx, convID, CompactInput{}) + if err != nil { + t.Fatalf("Compact: %v", err) + } + if result == nil { + t.Fatal("expected non-nil result") + } + + // Should have created at least one leaf summary + if result.LeafSummaries == 0 { + t.Error("expected at least 1 leaf summary") + } + + // Context should now contain a summary item + items, _ := s.GetContextItems(ctx, convID) + foundSummary := false + for _, item := range items { + if item.ItemType == "summary" { + foundSummary = true + break + } + } + if !foundSummary { + t.Error("expected a summary in context_items after leaf compaction") + } + + // Some messages should have been replaced + if len(result.SummariesCreated) == 0 { + t.Error("expected at least 1 summary created") + } +} + +func TestCompactLeafNoCandidate(t *testing.T) { + ce, _, convID := newTestCompactionEngine(t) + ctx := context.Background() + + // Too few messages to trigger leaf compaction + m, _ := ce.store.AddMessage(ctx, convID, "user", "short", 10) + ce.store.AppendContextMessage(ctx, convID, m.ID) + + result, err := ce.Compact(ctx, convID, CompactInput{}) + if err != nil { + t.Fatalf("Compact: %v", err) + } + if result == nil { + t.Fatal("expected non-nil result even with no candidate") + } + if result.LeafSummaries != 0 { + t.Errorf("LeafSummaries = %d, want 0 (too few messages)", result.LeafSummaries) + } +} + +func TestCompactCondensed(t *testing.T) { + ce, s, convID := newTestCompactionEngine(t) + ctx := context.Background() + + // Create enough leaf summaries and fresh messages to enable condensation + leafIDs := make([]string, CondensedMinFanout) + for i := 0; i < CondensedMinFanout; i++ { + now := time.Now().UTC() + summary, err := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "leaf summary content " + time.Now().String(), + TokenCount: 500, + EarliestAt: &now, + LatestAt: &now, + }) + if err != nil { + t.Fatalf("CreateSummary %d: %v", i, err) + } + leafIDs[i] = summary.SummaryID + s.AppendContextSummary(ctx, convID, summary.SummaryID) + } + + // Add enough fresh messages to have a fresh tail (>= FreshTailCount) + for i := 0; i < FreshTailCount; i++ { + m, _ := s.AddMessage(ctx, convID, "user", "fresh message", 10) + s.AppendContextMessage(ctx, convID, m.ID) + } + + // Compact with force to trigger condensation + _, err := ce.Compact(ctx, convID, CompactInput{Force: true}) + if err != nil { + t.Fatalf("Compact: %v", err) + } + + // Wait for async condensed goroutine to complete + if !waitForCondensed(ce, convID, 2*time.Second) { + t.Fatal("timeout waiting for condensed compaction") + } + + // Should have created a condensed summary in the DB + summaries, _ := s.GetSummariesByConversation(ctx, convID) + foundCondensed := false + for _, sum := range summaries { + if sum.Kind == SummaryKindCondensed { + foundCondensed = true + break + } + } + if !foundCondensed { + t.Error("expected at least 1 condensed summary") + } +} + +func TestCompactCondensedDoesNotOrphanSummaryWhenCandidatesRemovedConcurrently(t *testing.T) { + // Reproduce orphan bug: candidates found by selectOldestChunkAtDepth are removed + // from context_items between candidate selection and ordinal range scan. + // Use a slow CompleteFn with barrier sync to control timing. + s := openTestStore(t) + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "test:orphan-race") + convID := conv.ConversationID + + // Create leaf summaries with enough tokens for condensation + var leafIDs []string + for i := 0; i < CondensedMinFanout; i++ { + now := time.Now().UTC() + sum, err := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: fmt.Sprintf("leaf summary %d", i), + TokenCount: 500, + EarliestAt: &now, + LatestAt: &now, + }) + if err != nil { + t.Fatalf("CreateSummary: %v", err) + } + leafIDs = append(leafIDs, sum.SummaryID) + s.AppendContextSummary(ctx, convID, sum.SummaryID) + } + + // Add fresh tail so leaf summaries are in evictable range + for i := 0; i < FreshTailCount+1; i++ { + m, _ := s.AddMessage(ctx, convID, "user", "fresh", 10) + s.AppendContextMessage(ctx, convID, m.ID) + } + + // Barrier: CompleteFn waits until test removes context_items, then returns + var barrier1, barrier2 sync.WaitGroup + barrier1.Add(1) // CompleteFn signals when called + barrier2.Add(1) // test signals when context_items removed + + slowComplete := func(ctx context.Context, prompt string, opts CompleteOptions) (string, error) { + barrier1.Done() // signal: LLM called, candidates selected + barrier2.Wait() // wait: test removes context_items + return "Condensed summary.", nil + } + + ce, cancel := newTestCompactionEngineWithStore(s, slowComplete) + t.Cleanup(func() { + cancel() + time.Sleep(100 * time.Millisecond) + }) + + // Run compactCondensed in background + type compactResult struct { + summaryID *string + err error + } + resultCh := make(chan compactResult, 1) + go func() { + sid, err := ce.compactCondensed(context.Background(), convID) + resultCh <- compactResult{summaryID: sid, err: err} + }() + + // Wait for CompleteFn to be called (candidates selected) + barrier1.Wait() + + // Remove leaf summaries from context_items (simulating concurrent replacement) + items, _ := s.GetContextItems(ctx, convID) + var preserved []ContextItem + for _, item := range items { + isLeaf := false + for _, lid := range leafIDs { + if item.SummaryID == lid { + isLeaf = true + break + } + } + if !isLeaf { + preserved = append(preserved, item) + } + } + s.UpsertContextItems(ctx, convID, preserved) + + // Let CompleteFn return + barrier2.Done() + + // Get result + res := <-resultCh + if res.err != nil { + t.Fatalf("compactCondensed: %v", res.err) + } + + // With the bug: returns non-nil summaryID even though context_items has no matching ordinals + // The fix: should return nil when startOrd == -1 + if res.summaryID != nil { + t.Errorf("compactCondensed returned summaryID=%s, want nil (orphan created)", *res.summaryID) + + // Verify the orphan exists in DB + summary, _ := s.GetSummary(context.Background(), *res.summaryID) + if summary != nil && summary.Kind == SummaryKindCondensed { + // Check it's NOT in context_items (orphan) + items2, _ := s.GetContextItems(context.Background(), convID) + found := false + for _, item := range items2 { + if item.SummaryID == *res.summaryID { + found = true + break + } + } + if !found { + t.Error("condensed summary exists in DB but not in context_items — orphan confirmed") + } + } + } +} + +func TestCompactUntilUnder(t *testing.T) { + ce, s, convID := newTestCompactionEngine(t) + ctx := context.Background() + + // Create many leaf summaries to ensure we can condense + for i := 0; i < 8; i++ { + now := time.Now().UTC() + summary, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "leaf summary for condensation test", + TokenCount: 500, + EarliestAt: &now, + LatestAt: &now, + }) + s.AppendContextSummary(ctx, convID, summary.SummaryID) + } + + // Force compact until under budget + result, err := ce.CompactUntilUnder(ctx, convID, 2000) + if err != nil { + t.Fatalf("CompactUntilUnder: %v", err) + } + + if result == nil { + t.Fatal("expected non-nil result") + } +} + +func TestSelectShallowestCondensationCandidate(t *testing.T) { + ce, s, convID := newTestCompactionEngine(t) + ctx := context.Background() + + // Create enough leaf summaries + fresh messages for candidates + for i := 0; i < LeafMinFanout; i++ { + summary, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "leaf", + TokenCount: 100, + }) + s.AppendContextSummary(ctx, convID, summary.SummaryID) + } + + // Add fresh tail messages so summaries are in evictable range + for i := 0; i < FreshTailCount+1; i++ { + m, _ := s.AddMessage(ctx, convID, "user", "fresh", 5) + s.AppendContextMessage(ctx, convID, m.ID) + } + + candidates, err := ce.selectShallowestCondensationCandidate(ctx, convID, false) + if err != nil { + t.Fatalf("selectShallowestCondensationCandidate: %v", err) + } + + // Should find leaf summaries at depth 0 + if len(candidates) < CondensedMinFanout { + t.Errorf("candidates = %d, want >= %d", len(candidates), CondensedMinFanout) + } +} + +func TestSelectShallowestCondensationCandidateEmpty(t *testing.T) { + ce, _, convID := newTestCompactionEngine(t) + ctx := context.Background() + + candidates, err := ce.selectShallowestCondensationCandidate(ctx, convID, false) + if err != nil { + t.Fatalf("selectShallowestCondensationCandidate: %v", err) + } + if len(candidates) != 0 { + t.Errorf("candidates = %d, want 0 for empty context", len(candidates)) + } +} + +func TestCompactCondensedUsesSelectOldestChunk(t *testing.T) { + // Verify that compactCondensed prefers ordinal-ordered chunks via selectOldestChunkAtDepth + // rather than just grouping by depth without regard to order + ce, s, convID := newTestCompactionEngine(t) + ctx := context.Background() + + // Create interleaved summaries at depth 0 with a message in between: + // sum1 (ordinal 100), msg (ordinal 200), sum2 (ordinal 300) + + for i := 0; i < LeafMinFanout+2; i++ { + now := time.Now().UTC() + + s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: fmt.Sprintf("leaf summary %d", i), + TokenCount: 100, + EarliestAt: &now, + LatestAt: &now, + }) + } + + // Insert a message between first two summaries to break contiguity + // for selectShallowestCondensationCandidate but would still find all 3 + // but selectOldestChunkAtDepth should only find sum1 + sum2 (not sum3) + + msg, _ := s.AddMessage(ctx, convID, "user", "interrupting message", 5) + s.AppendContextMessage(ctx, convID, msg.ID) + + // Run compactCondensed + result, err := ce.compactCondensed(ctx, convID) + if err != nil { + t.Fatalf("compactCondensed: %v", err) + } + + // The result should have merged the two summaries at the start + // (skipping the message in between), This proves ordinal-aware selection works. + + _ = result // verify summary was created + + if result != nil { + summaries, _ := s.GetSummariesByConversation(ctx, convID) + found := false + for _, sum := range summaries { + if sum.Kind == SummaryKindCondensed { + found = true + break + } + } + if !found { + t.Error("expected condensed summary to be created via ordinal-aware selection") + } + } +} + +func TestCompactCondensedUsesOrdinalAwareSelection(t *testing.T) { + ce, s, convID := newTestCompactionEngine(t) + ctx := context.Background() + + // Create leaf summaries at depth 0 (total tokens >= CondensedTargetTokens) + for i := 0; i < 5; i++ { + summary, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: fmt.Sprintf("leaf summary %d", i), + TokenCount: 500, // 5 × 500 = 2500 >= CondensedTargetTokens (2000) + }) + s.AppendContextSummary(ctx, convID, summary.SummaryID) + } + + // Add fresh tail + for i := 0; i < FreshTailCount+1; i++ { + m, _ := s.AddMessage(ctx, convID, "user", "fresh", 5) + s.AppendContextMessage(ctx, convID, m.ID) + } + + chunk, err := ce.selectOldestChunkAtDepth(ctx, convID, 0) + if err != nil { + t.Fatalf("selectOldestChunkAtDepth: %v", err) + } + if len(chunk) < 2 { + t.Errorf("chunk length = %d, want >= 2 contiguous summaries", len(chunk)) + } + for _, s := range chunk { + if s.Depth != 0 { + t.Errorf("got depth %d, want 0", s.Depth) + } + } +} + +func TestSelectOldestChunkAtDepthBreaksOnMessage(t *testing.T) { + ce, s, convID := newTestCompactionEngine(t) + ctx := context.Background() + + // Create 3 summaries, then a message, then 3 more summaries + for i := 0; i < 3; i++ { + summary, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: fmt.Sprintf("leaf %d", i), + TokenCount: 100, + }) + s.AppendContextSummary(ctx, convID, summary.SummaryID) + } + msg, _ := s.AddMessage(ctx, convID, "user", "break", 10) + s.AppendContextMessage(ctx, convID, msg.ID) + for i := 0; i < 3; i++ { + summary, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: fmt.Sprintf("leaf-after %d", i), + TokenCount: 100, + }) + s.AppendContextSummary(ctx, convID, summary.SummaryID) + } + for i := 0; i < FreshTailCount+1; i++ { + m, _ := s.AddMessage(ctx, convID, "user", "fresh", 5) + s.AppendContextMessage(ctx, convID, m.ID) + } + + chunk, _ := ce.selectOldestChunkAtDepth(ctx, convID, 0) + if len(chunk) > 3 { + t.Errorf("chunk length = %d, want <= 3 (message breaks chain)", len(chunk)) + } +} + +func TestSelectOldestChunkAtDepthMinTokens(t *testing.T) { + ce, s, convID := newTestCompactionEngine(t) + ctx := context.Background() + + // Create summaries with very low token counts (total < 2000) + for i := 0; i < 5; i++ { + summary, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: fmt.Sprintf("tiny summary %d", i), + TokenCount: 50, // very small + }) + s.AppendContextSummary(ctx, convID, summary.SummaryID) + } + + // Add fresh tail to protect from compaction + for i := 0; i < FreshTailCount+1; i++ { + m, _ := s.AddMessage(ctx, convID, "user", fmt.Sprintf("tail %d", i), 10) + s.AppendContextMessage(ctx, convID, m.ID) + } + + // Should return nil because total tokens (250) < 2000 minimum + chunk, err := ce.selectOldestChunkAtDepth(ctx, convID, 0) + if err != nil { + t.Fatalf("selectOldestChunkAtDepth: %v", err) + } + if len(chunk) > 0 { + t.Errorf("expected empty chunk when tokens < 2000, got %d summaries", len(chunk)) + } +} + +func TestSelectOldestChunkAtDepthPassesMinTokens(t *testing.T) { + ce, s, convID := newTestCompactionEngine(t) + ctx := context.Background() + + // Create summaries with enough tokens (total >= 2000) + for i := 0; i < 5; i++ { + summary, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: fmt.Sprintf( + "substantial summary with enough content to meet minimum token threshold for condensation candidate %d", + i, + ), + TokenCount: 500, // 5 × 500 = 2500 >= 2000 + }) + s.AppendContextSummary(ctx, convID, summary.SummaryID) + } + + // Add fresh tail + for i := 0; i < FreshTailCount+1; i++ { + m, _ := s.AddMessage(ctx, convID, "user", fmt.Sprintf("tail %d", i), 10) + s.AppendContextMessage(ctx, convID, m.ID) + } + + // Should return chunk because total tokens (2500) >= 2000 + chunk, err := ce.selectOldestChunkAtDepth(ctx, convID, 0) + if err != nil { + t.Fatalf("selectOldestChunkAtDepth: %v", err) + } + if len(chunk) == 0 { + t.Error("expected non-empty chunk when tokens >= 2000") + } +} + +func TestGenerateLeafSummary(t *testing.T) { + ce, _, _ := newTestCompactionEngine(t) + ctx := context.Background() + + msgs := []Message{ + {Role: "user", Content: "hello world", TokenCount: 5}, + {Role: "assistant", Content: "hi there", TokenCount: 5}, + } + + content, err := ce.generateLeafSummary(ctx, msgs, "") + if err != nil { + t.Fatalf("generateLeafSummary: %v", err) + } + if content == "" { + t.Error("expected non-empty summary content") + } +} + +func TestGenerateLeafSummaryEscalationToAggressive(t *testing.T) { + // Level 1 returns summary that's too large (tokens >= input), should escalate to level 2 + var calls []string + escalateComplete := func(ctx context.Context, prompt string, opts CompleteOptions) (string, error) { + if contains(prompt, "Aggressive summary policy") { + calls = append(calls, "aggressive") + return "Short aggressive summary.", nil + } + calls = append(calls, "normal") + // Return a very long summary to trigger escalation + longContent := make([]byte, 5000) + for i := range longContent { + longContent[i] = 'x' + } + return string(longContent), nil + } + + s := openTestStore(t) + ce, _ := newTestCompactionEngineWithStore(s, escalateComplete) + + msgs := []Message{ + {Role: "user", Content: "hello world", TokenCount: 10}, + {Role: "assistant", Content: "response", TokenCount: 10}, + } + + content, err := ce.generateLeafSummary(context.Background(), msgs, "") + if err != nil { + t.Fatalf("generateLeafSummary: %v", err) + } + if content == "" { + t.Error("expected non-empty summary content") + } + // Should have called both normal and aggressive + foundNormal := false + foundAggressive := false + for _, c := range calls { + if c == "normal" { + foundNormal = true + } + if c == "aggressive" { + foundAggressive = true + } + } + if !foundNormal { + t.Error("expected normal LLM call") + } + if !foundAggressive { + t.Error("expected aggressive LLM call (level 2 escalation)") + } +} + +func TestGenerateLeafSummaryEscalationToTruncation(t *testing.T) { + // Both normal and aggressive return empty, should escalate to level 3 truncation + emptyComplete := func(ctx context.Context, prompt string, opts CompleteOptions) (string, error) { + return "", nil + } + + s := openTestStore(t) + ce, _ := newTestCompactionEngineWithStore(s, emptyComplete) + + msgs := []Message{ + {Role: "user", Content: "hello world from test", TokenCount: 10}, + {Role: "assistant", Content: "response text here", TokenCount: 10}, + } + + content, err := ce.generateLeafSummary(context.Background(), msgs, "") + if err != nil { + t.Fatalf("generateLeafSummary: %v", err) + } + // Level 3 truncation should have produced something + if content == "" { + t.Error("expected non-empty content from level 3 truncation fallback") + } + if !contains(content, "Truncated from") { + t.Errorf("expected truncation marker in content: %q", content) + } +} + +func TestGenerateCondensedSummary(t *testing.T) { + ce, _, _ := newTestCompactionEngine(t) + ctx := context.Background() + + summaries := []Summary{ + {SummaryID: "sum_a", Content: "first summary", TokenCount: 100}, + {SummaryID: "sum_b", Content: "second summary", TokenCount: 100}, + } + + content, err := ce.generateCondensedSummary(ctx, summaries) + if err != nil { + t.Fatalf("generateCondensedSummary: %v", err) + } + if content == "" { + t.Error("expected non-empty condensed summary content") + } +} + +func TestGenerateCondensedSummaryEscalation(t *testing.T) { + // When LLM returns empty, should fall back to deterministic concatenation + emptyComplete := func(ctx context.Context, prompt string, opts CompleteOptions) (string, error) { + return "", nil + } + + s := openTestStore(t) + ce, _ := newTestCompactionEngineWithStore(s, emptyComplete) + + summaries := []Summary{ + {SummaryID: "sum_a", Content: "first summary text", TokenCount: 50}, + {SummaryID: "sum_b", Content: "second summary text", TokenCount: 50}, + } + + content, err := ce.generateCondensedSummary(context.Background(), summaries) + if err != nil { + t.Fatalf("generateCondensedSummary: %v", err) + } + // Should fall back to concatenation + if content == "" { + t.Error("expected non-empty content from fallback") + } +} + +// --- Async Condensed Compaction (Phase 2) --- + +func TestCompactAsyncReturnsBeforeCondensed(t *testing.T) { + // Use a slow CompleteFn to verify Compact returns before condensed finishes + var callCount int32 + slowComplete := func(ctx context.Context, prompt string, opts CompleteOptions) (string, error) { + atomic.AddInt32(&callCount, 1) + time.Sleep(500 * time.Millisecond) // simulate slow LLM + return "Slow condensed summary.", nil + } + + s := openTestStore(t) + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "test:async") + convID := conv.ConversationID + + ce, cancel := newTestCompactionEngineWithStore(s, slowComplete) + t.Cleanup(func() { + cancel() + time.Sleep(100 * time.Millisecond) + }) + + // Create enough leaf summaries for condensation + fresh tail + for i := 0; i < CondensedMinFanout; i++ { + now := time.Now().UTC() + summary, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "leaf for async test", + TokenCount: 500, + EarliestAt: &now, + LatestAt: &now, + }) + s.AppendContextSummary(ctx, convID, summary.SummaryID) + } + for i := 0; i < FreshTailCount; i++ { + m, _ := s.AddMessage(ctx, convID, "user", "fresh", 10) + s.AppendContextMessage(ctx, convID, m.ID) + } + + // Compact with force — should return quickly, condensed runs async + start := time.Now() + result, err := ce.Compact(ctx, convID, CompactInput{Force: true}) + elapsed := time.Since(start) + + if err != nil { + t.Fatalf("Compact: %v", err) + } + if result == nil { + t.Fatal("expected non-nil result") + } + + // Should return well before the 500ms LLM call + if elapsed > 200*time.Millisecond { + t.Errorf("Compact took %v, should return before async condensed finishes", elapsed) + } + + // Wait for async to complete + time.Sleep(800 * time.Millisecond) + + // Verify condensed summary was created by background goroutine + summaries, _ := s.GetSummariesByConversation(ctx, convID) + foundCondensed := false + for _, sum := range summaries { + if sum.Kind == SummaryKindCondensed { + foundCondensed = true + break + } + } + if !foundCondensed { + t.Error("expected at least one condensed summary from async Phase 2") + } +} + +func TestCompactAsyncDedup(t *testing.T) { + var callCount int32 + slowComplete := func(ctx context.Context, prompt string, opts CompleteOptions) (string, error) { + atomic.AddInt32(&callCount, 1) + time.Sleep(300 * time.Millisecond) + return "Slow condensed summary.", nil + } + + s := openTestStore(t) + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "test:dedup") + convID := conv.ConversationID + + ce, cancel := newTestCompactionEngineWithStore(s, slowComplete) + t.Cleanup(func() { + cancel() + waitForCondensed(ce, convID, 2*time.Second) + }) + + // Create conditions for condensed compaction + for i := 0; i < CondensedMinFanout; i++ { + now := time.Now().UTC() + summary, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "leaf for dedup", + TokenCount: 500, + EarliestAt: &now, + LatestAt: &now, + }) + s.AppendContextSummary(ctx, convID, summary.SummaryID) + } + for i := 0; i < FreshTailCount; i++ { + m, _ := s.AddMessage(ctx, convID, "user", "fresh", 10) + s.AppendContextMessage(ctx, convID, m.ID) + } + + // Call Compact twice rapidly + ce.Compact(ctx, convID, CompactInput{Force: true}) + ce.Compact(ctx, convID, CompactInput{Force: true}) + + // Wait for async to finish + time.Sleep(600 * time.Millisecond) + + // LLM should only be called once for condensed (dedup) + // callCount may be 0 if no leaf was created (only condensed in goroutine) + // The key is that we don't get 2+ condensed calls + if atomic.LoadInt32(&callCount) > 1 { + t.Errorf("LLM called %d times, expected at most 1 (dedup)", callCount) + } +} + +func TestCompactLeafForceBypassesFreshTail(t *testing.T) { + // Spec: compactLeaf with force=true should bypass FreshTailCount protection + // so CompactUntilUnder can compress messages inside the fresh tail + ce, s, convID := newTestCompactionEngine(t) + ctx := context.Background() + + // Create exactly FreshTailCount+4 messages (36 total) + // Without force: all messages are in fresh tail → no candidate + // With force: should compact the oldest messages + total := FreshTailCount + 4 + for i := 0; i < total; i++ { + m, _ := s.AddMessage(ctx, convID, "user", fmt.Sprintf("message %d for force test", i), 100) + s.AppendContextMessage(ctx, convID, m.ID) + } + + // Without force: should return nil (all in fresh tail) + summaryID, err := ce.compactLeaf(ctx, convID) + if err != nil { + t.Fatalf("compactLeaf no-force: %v", err) + } + if summaryID != nil { + t.Error("expected nil without force (all messages in fresh tail)") + } + + // With force: should compact despite fresh tail protection + summaryID, err = ce.compactLeaf(ctx, convID, true) + if err != nil { + t.Fatalf("compactLeaf force: %v", err) + } + if summaryID == nil { + t.Error("expected summary with force=true (bypasses fresh tail)") + } +} + +func TestCompactLeafAccumulatesUpToLeafChunkTokens(t *testing.T) { + // Spec: compactLeaf should accumulate messages up to LeafChunkTokens before stopping + // It should NOT take the entire contiguous chunk regardless of token count + ce, s, convID := newTestCompactionEngine(t) + ctx := context.Background() + + // Create messages totaling far more than LeafChunkTokens (20000) + // Each message is ~500 tokens, create 80 messages = 40000 tokens + for i := 0; i < 80; i++ { + m, _ := s.AddMessage( + ctx, + convID, + "user", + fmt.Sprintf( + "message %d with lots of content to make it big enough for token counting purposes and this should be a substantial message body that represents a meaningful conversation turn", + i, + ), + 500, + ) + s.AppendContextMessage(ctx, convID, m.ID) + } + + summaryID, err := ce.compactLeaf(ctx, convID) + if err != nil { + t.Fatalf("compactLeaf: %v", err) + } + if summaryID == nil { + t.Fatal("expected a summary to be created") + } + + // The source messages that were compacted should total roughly LeafChunkTokens (20000), + // not the entire 40000 tokens worth of messages + summary, _ := s.GetSummary(ctx, *summaryID) + if summary == nil { + t.Fatal("summary not found") + } + + // Source message tokens should be roughly <= LeafChunkTokens (20000) + // Spec says: "Stop when accumulated tokens >= LeafChunkTokens" + if summary.SourceMessageTokenCount > LeafChunkTokens { + t.Errorf("source tokens = %d, should be <= LeafChunkTokens (%d)", + summary.SourceMessageTokenCount, LeafChunkTokens) + } +} diff --git a/pkg/seahorse/short_constants.go b/pkg/seahorse/short_constants.go new file mode 100644 index 000000000..943d7931e --- /dev/null +++ b/pkg/seahorse/short_constants.go @@ -0,0 +1,30 @@ +package seahorse + +// Short-term memory configuration constants — all are experience-based defaults. + +const ( + // OrdinalStep is the gap between ordinals in context_items. + // Insert at midpoint; resequence only when precision exhausted. + OrdinalStep = 100 + + // ContextThreshold is the compaction trigger for the context window. + ContextThreshold float64 = 0.75 // Compact at 75% of context window + FreshTailCount int = 32 // Recent messages protected from compaction + + // LeafMinFanout is the fanout parameter. + LeafMinFanout int = 8 // Min messages per leaf summary + CondensedMinFanout int = 4 // Min summaries per condensed + CondensedMinFanoutHard int = 2 // Min for forced compaction + + // LeafChunkTokens is the token target. + LeafChunkTokens int = 20000 // Max tokens per leaf chunk + LeafTargetTokens int = 1200 // Target tokens for leaf summaries + CondensedTargetTokens int = 2000 // Target tokens for condensed summaries + MaxExpandTokens int = 4000 // Token cap for expansion queries + + // MaxCompactIterations caps CompactUntilUnder to prevent infinite loops. + // Each iteration reduces ~4x tokens via leaf (8:1) or condensed (4:1) compaction. + // With a 200k token context window and 75% threshold, ~20 iterations is enough + // for any realistic scenario. If exceeded, the issue is logged as a warning. + MaxCompactIterations int = 20 +) diff --git a/pkg/seahorse/short_engine.go b/pkg/seahorse/short_engine.go new file mode 100644 index 000000000..4cd4d3887 --- /dev/null +++ b/pkg/seahorse/short_engine.go @@ -0,0 +1,568 @@ +package seahorse + +import ( + "context" + "database/sql" + "fmt" + "os" + "path/filepath" + "regexp" + "strings" + "sync" + + _ "modernc.org/sqlite" + + "github.com/sipeed/picoclaw/pkg/logger" +) + +// Config holds engine configuration. +type Config struct { + DBPath string `json:"dbPath"` + IgnoreSessionPatterns []string `json:"ignoreSessionPatterns,omitempty"` + StatelessSessionPatterns []string `json:"statelessSessionPatterns,omitempty"` +} + +// CompleteFn is the LLM completion function type. +type CompleteFn func(ctx context.Context, prompt string, opts CompleteOptions) (string, error) + +// CompleteOptions holds LLM completion parameters. +type CompleteOptions struct { + Model string + MaxTokens int + Temperature float64 +} + +// IngestResult is the result of message ingestion. +type IngestResult struct { + MessageCount int `json:"messageCount"` + TokenCount int `json:"tokenCount"` +} + +// AssembleInput controls context assembly. +type AssembleInput struct { + Budget int `json:"budget"` + Query string `json:"query,omitempty"` +} + +// AssembleResult contains assembled context. +type AssembleResult struct { + Messages []Message `json:"messages"` + Summary string `json:"summary"` // formatted XML summaries + system prompt addition +} + +const numSessionShards = 256 + +// Engine is the main short-term memory engine. +type Engine struct { + store *Store + compaction *CompactionEngine + compactionMu sync.Mutex + assembler *Assembler + assemblerMu sync.Mutex + retrieval *RetrievalEngine + config Config + complete CompleteFn + ignorePatterns []*regexp.Regexp + statelessPatterns []*regexp.Regexp + sessionShards [numSessionShards]struct { + mu sync.Mutex + } +} + +// CompactionEngine handles LLM-based summarization (defined in short_compaction.go). +type CompactionEngine struct { + store *Store + config Config + complete CompleteFn + condensing sync.Map // map[int64]struct{} — dedup for async condensed goroutines + shutdownCtx context.Context + shutdownCancel context.CancelFunc +} + +// Assembler handles budget-aware context assembly (defined in short_assembler.go). +type Assembler struct { + store *Store + config Config +} + +// RetrievalEngine handles search and expansion (defined in short_retrieval.go). +type RetrievalEngine struct { + store *Store + config Config +} + +// Store returns the underlying store for direct access. +func (r *RetrievalEngine) Store() *Store { + return r.store +} + +// NewEngine creates a new short-term memory engine. +func NewEngine(config Config, completeFn CompleteFn) (*Engine, error) { + dir := filepath.Dir(config.DBPath) + if dir != "" && dir != "." { + if err := os.MkdirAll(dir, 0o755); err != nil { + return nil, fmt.Errorf("create db directory: %w", err) + } + } + + db, err := sql.Open("sqlite", config.DBPath) + if err != nil { + return nil, fmt.Errorf("open db: %w", err) + } + + // Configure SQLite for concurrent access + if _, err := db.Exec("PRAGMA journal_mode = WAL;"); err != nil { + db.Close() + return nil, fmt.Errorf("enable WAL: %w", err) + } + if _, err := db.Exec("PRAGMA busy_timeout = 5000;"); err != nil { + db.Close() + return nil, fmt.Errorf("set busy_timeout: %w", err) + } + if _, err := db.Exec("PRAGMA synchronous = NORMAL;"); err != nil { + db.Close() + return nil, fmt.Errorf("set synchronous: %w", err) + } + + if err := runSchema(db); err != nil { + db.Close() + return nil, fmt.Errorf("migrations: %w", err) + } + + store := &Store{db: db} + + // Prepend hardcoded ignore patterns (spec lines 1326-1328) + ignorePatterns := make([]string, 0, 1+len(config.IgnoreSessionPatterns)) + ignorePatterns = append(ignorePatterns, "heartbeat") + ignorePatterns = append(ignorePatterns, config.IgnoreSessionPatterns...) + + retrieval := &RetrievalEngine{store: store, config: config} + + return &Engine{ + store: store, + compaction: nil, + assembler: nil, + retrieval: retrieval, + config: config, + complete: completeFn, + ignorePatterns: compileSessionPatterns(ignorePatterns), + statelessPatterns: compileSessionPatterns(config.StatelessSessionPatterns), + }, nil +} + +// compileSessionPattern converts a glob pattern to a compiled regex. +// Pattern rules: +// - * matches any sequence of non-colon characters ([^:]*) +// - ** matches any sequence of characters including colons (.*) +// - All other characters are treated literally +// - Pattern is anchored (^...$) +func compileSessionPattern(pattern string) *regexp.Regexp { + var b strings.Builder + b.WriteByte('^') + + i := 0 + for i < len(pattern) { + if i+1 < len(pattern) && pattern[i] == '*' && pattern[i+1] == '*' { + b.WriteString(".*") + i += 2 + continue + } + if pattern[i] == '*' { + b.WriteString("[^:]*") + i++ + continue + } + b.WriteString(regexp.QuoteMeta(string(pattern[i]))) + i++ + } + + b.WriteByte('$') + return regexp.MustCompile(b.String()) +} + +// compileSessionPatterns compiles multiple glob patterns into regex patterns. +func compileSessionPatterns(patterns []string) []*regexp.Regexp { + result := make([]*regexp.Regexp, 0, len(patterns)) + for _, p := range patterns { + if p == "" { + continue + } + result = append(result, compileSessionPattern(p)) + } + return result +} + +// shouldIgnoreSession returns true if the session key matches any ignore pattern. +func (e *Engine) shouldIgnoreSession(sessionKey string) bool { + for _, p := range e.ignorePatterns { + if p.MatchString(sessionKey) { + return true + } + } + return false +} + +// isStatelessSession returns true if the session key matches any stateless pattern. +func (e *Engine) isStatelessSession(sessionKey string) bool { + for _, p := range e.statelessPatterns { + if p.MatchString(sessionKey) { + return true + } + } + return false +} + +// fnv32 computes FNV-1a 32-bit hash for session key sharding. +func fnv32(key string) uint32 { + h := uint32(2166136261) + for _, c := range key { + h ^= uint32(c) + h *= 16777619 + } + return h +} + +// getSessionMutex returns the sharded mutex for a session key. +func (e *Engine) getSessionMutex(sessionKey string) *sync.Mutex { + h := fnv32(sessionKey) + shard := h % numSessionShards + return &e.sessionShards[shard].mu +} + +// Ingest adds messages to a conversation identified by sessionKey. +func (e *Engine) Ingest(ctx context.Context, sessionKey string, messages []Message) (*IngestResult, error) { + if e.shouldIgnoreSession(sessionKey) { + return nil, nil + } + if e.isStatelessSession(sessionKey) { + return nil, nil + } + + mu := e.getSessionMutex(sessionKey) + mu.Lock() + defer mu.Unlock() + + conv, err := e.store.GetOrCreateConversation(ctx, sessionKey) + if err != nil { + return nil, fmt.Errorf("get conversation: %w", err) + } + + var totalTokens int + var msgIDs []int64 + for _, msg := range messages { + var added *Message + var err error + if len(msg.Parts) > 0 { + added, err = e.store.AddMessageWithParts(ctx, conv.ConversationID, msg.Role, msg.Parts, msg.TokenCount) + } else { + added, err = e.store.AddMessage(ctx, conv.ConversationID, msg.Role, msg.Content, msg.TokenCount) + } + if err != nil { + return nil, fmt.Errorf("add message: %w", err) + } + totalTokens += msg.TokenCount + msgIDs = append(msgIDs, added.ID) + } + + // Append to context_items using actual inserted IDs + if err := e.store.AppendContextMessages(ctx, conv.ConversationID, msgIDs); err != nil { + return nil, fmt.Errorf("append context: %w", err) + } + + logger.InfoCF("seahorse", "ingest", map[string]any{ + "conv_id": conv.ConversationID, + "messages": len(messages), + "tokens": totalTokens, + }) + return &IngestResult{ + MessageCount: len(messages), + TokenCount: totalTokens, + }, nil +} + +// Close releases resources. +func (e *Engine) Close() error { + // Signal compaction goroutines to stop + if e.compaction != nil { + e.compaction.Close() + } + if e.store != nil && e.store.db != nil { + return e.store.db.Close() + } + return nil +} + +// GetRetrieval returns the retrieval engine for tool implementations. +func (e *Engine) GetRetrieval() *RetrievalEngine { + return e.retrieval +} + +// Assemble builds budget-constrained context for a session. +func (e *Engine) Assemble(ctx context.Context, sessionKey string, input AssembleInput) (*AssembleResult, error) { + if e.shouldIgnoreSession(sessionKey) { + return nil, nil + } + + conv, err := e.store.GetOrCreateConversation(ctx, sessionKey) + if err != nil { + return nil, fmt.Errorf("get conversation: %w", err) + } + + e.initAssemblerOnce() + return e.assembler.Assemble(ctx, conv.ConversationID, input) +} + +// Compact compresses conversation history for a session. +func (e *Engine) Compact(ctx context.Context, sessionKey string, input CompactInput) (*CompactResult, error) { + if e.shouldIgnoreSession(sessionKey) || e.isStatelessSession(sessionKey) { + return &CompactResult{}, nil + } + + conv, err := e.store.GetOrCreateConversation(ctx, sessionKey) + if err != nil { + return nil, fmt.Errorf("get conversation: %w", err) + } + + e.initCompactionOnce() + return e.compaction.Compact(ctx, conv.ConversationID, input) +} + +// CompactUntilUnder aggressively compacts until context is under budget. +// Used for emergency compaction after LLM overflow (retry reason). +func (e *Engine) CompactUntilUnder(ctx context.Context, sessionKey string, budget int) (*CompactResult, error) { + if e.shouldIgnoreSession(sessionKey) || e.isStatelessSession(sessionKey) { + return &CompactResult{}, nil + } + + conv, err := e.store.GetOrCreateConversation(ctx, sessionKey) + if err != nil { + return nil, fmt.Errorf("get conversation: %w", err) + } + + e.initCompactionOnce() + return e.compaction.CompactUntilUnder(ctx, conv.ConversationID, budget) +} + +// initCompactionOnce lazily initializes the compaction engine. +func (e *Engine) initCompactionOnce() { + if e.compaction == nil { + e.compactionMu.Lock() + defer e.compactionMu.Unlock() + if e.compaction == nil { + shutdownCtx, shutdownCancel := context.WithCancel(context.Background()) + e.compaction = &CompactionEngine{ + store: e.store, + config: e.config, + complete: e.complete, + shutdownCtx: shutdownCtx, + shutdownCancel: shutdownCancel, + } + } + } +} + +// initAssemblerOnce lazily initializes the assembler. +func (e *Engine) initAssemblerOnce() { + if e.assembler == nil { + e.assemblerMu.Lock() + defer e.assemblerMu.Unlock() + if e.assembler == nil { + e.assembler = &Assembler{store: e.store, config: e.config} + } + } +} + +// IngestMessages is an alias for Ingest. +func (e *Engine) IngestMessages(ctx context.Context, sessionKey string, messages []Message) (*IngestResult, error) { + return e.Ingest(ctx, sessionKey, messages) +} + +// Bootstrap reconciles a session's messages with the database. +// Called once at startup for each known session. +// Bootstrap reconciles JSONL history with SQLite by ingesting only the delta. +// Simple approach: find longest matching prefix and append delta. +// If any mismatch is detected, clear and rebuild. +func (e *Engine) Bootstrap(ctx context.Context, sessionKey string, messages []Message) error { + if e.shouldIgnoreSession(sessionKey) { + return nil + } + if e.isStatelessSession(sessionKey) { + return nil + } + if len(messages) == 0 { + return nil + } + + conv, err := e.store.GetOrCreateConversation(ctx, sessionKey) + if err != nil { + return fmt.Errorf("bootstrap: get conversation: %w", err) + } + + // Get messages already in DB + dbMsgs, err := e.store.GetMessages(ctx, conv.ConversationID, len(messages), 0) + if err != nil { + return fmt.Errorf("bootstrap: get messages: %w", err) + } + + // Fast path: DB has same count and exact match → no-op + if len(dbMsgs) == len(messages) { + matched := true + for i := 0; i < len(messages); i++ { + if !messageMatches(dbMsgs[i], messages[i]) { + matched = false + break + } + } + if matched { + return nil // DB is up to date + } + } + + // Find longest matching prefix from the start + anchor := -1 + compareLen := len(dbMsgs) + if compareLen > len(messages) { + compareLen = len(messages) + } + + for i := 0; i < compareLen; i++ { + if messageMatches(dbMsgs[i], messages[i]) { + anchor = i + } else { + // Mismatch detected - log details and rebuild + logger.InfoCF("seahorse", "bootstrap: mismatch detected", map[string]any{ + "conv_id": conv.ConversationID, + "index": i, + "db_role": dbMsgs[i].Role, + "db_content": truncate(dbMsgs[i].Content, 50), + "db_parts": len(dbMsgs[i].Parts), + "msg_role": messages[i].Role, + "msg_content": truncate(messages[i].Content, 50), + "msg_parts": len(messages[i].Parts), + }) + break + } + } + + // If we hit a mismatch before reaching the end of DB messages, delete delta and re-ingest + // Note: anchor can be -1 if first message didn't match (history completely changed) + if anchor >= 0 && anchor < len(dbMsgs)-1 && len(dbMsgs) > 0 { + anchorID := dbMsgs[anchor].ID + logger.InfoCF("seahorse", "bootstrap: history edit detected", map[string]any{ + "conv_id": conv.ConversationID, + "db_count": len(dbMsgs), + "anchor": anchor, + "anchor_id": anchorID, + "msg_count": len(messages), + "delta_start": anchor + 1, + }) + + // Delete messages after anchor (also clears context_items) + if err := e.store.DeleteMessagesAfterID(ctx, conv.ConversationID, anchorID); err != nil { + return fmt.Errorf("bootstrap: delete messages: %w", err) + } + + // Re-ingest from anchor+1 to end + delta := messages[anchor+1:] + if len(delta) > 0 { + _, err := e.Ingest(ctx, sessionKey, delta) + if err != nil { + return fmt.Errorf("bootstrap: re-ingest: %w", err) + } + } + return nil + } + + // Normal case: append delta after anchor + if anchor >= 0 && anchor < len(messages)-1 { + delta := messages[anchor+1:] + if len(delta) > 0 { + _, err := e.Ingest(ctx, sessionKey, delta) + if err != nil { + return fmt.Errorf("bootstrap: ingest delta: %w", err) + } + } + } else if anchor == -1 && len(dbMsgs) > 0 { + // First message changed (history completely different) - rebuild from scratch + logger.InfoCF("seahorse", "bootstrap: history replaced, rebuilding", map[string]any{ + "conv_id": conv.ConversationID, + "db_count": len(dbMsgs), + "msg_count": len(messages), + }) + // Delete all existing messages + if err := e.store.DeleteMessagesAfterID(ctx, conv.ConversationID, 0); err != nil { + return fmt.Errorf("bootstrap: delete all messages: %w", err) + } + // Re-ingest everything + if len(messages) > 0 { + _, err := e.Ingest(ctx, sessionKey, messages) + if err != nil { + return fmt.Errorf("bootstrap: re-ingest all: %w", err) + } + } + } else if anchor == -1 && len(dbMsgs) == 0 { + // DB is empty, ingest everything + _, err := e.Ingest(ctx, sessionKey, messages) + if err != nil { + return fmt.Errorf("bootstrap: ingest all: %w", err) + } + } + + return nil +} + +// truncate shortens a string for logging. +func truncate(s string, maxLen int) string { + if len(s) <= maxLen { + return s + } + return s[:maxLen] + "..." +} + +// messageMatches compares two messages using (role, content) or (role, parts). +// TokenCount is NOT compared because it may be re-estimated differently +// during bootstrap (e.g., via tokenizer.EstimateMessageTokens). +// For messages with Parts (tool_use, tool_result), compare Parts instead of Content +// since AddMessageWithParts stores empty Content in DB. +func messageMatches(a, b Message) bool { + if a.Role != b.Role { + return false + } + // If either message has Parts, compare Parts + if len(a.Parts) > 0 || len(b.Parts) > 0 { + return partsMatch(a.Parts, b.Parts) + } + // Simple text messages: compare Content + return a.Content == b.Content +} + +// partsMatch compares two slices of MessagePart for equality. +func partsMatch(a, b []MessagePart) bool { + if len(a) != len(b) { + return false + } + for i := range a { + if a[i].Type != b[i].Type { + return false + } + switch a[i].Type { + case "text": + if a[i].Text != b[i].Text { + return false + } + case "tool_use": + if a[i].Name != b[i].Name || a[i].Arguments != b[i].Arguments || a[i].ToolCallID != b[i].ToolCallID { + return false + } + case "tool_result": + if a[i].ToolCallID != b[i].ToolCallID || a[i].Text != b[i].Text { + return false + } + case "media": + if a[i].MediaURI != b[i].MediaURI || a[i].MimeType != b[i].MimeType { + return false + } + } + } + return true +} diff --git a/pkg/seahorse/short_engine_test.go b/pkg/seahorse/short_engine_test.go new file mode 100644 index 000000000..d64634fb7 --- /dev/null +++ b/pkg/seahorse/short_engine_test.go @@ -0,0 +1,1448 @@ +package seahorse + +import ( + "context" + "fmt" + "os" + "path/filepath" + "strings" + "sync" + "testing" + "time" +) + +// helper: open a test engine with in-memory DB +func newTestEngine(t *testing.T) *Engine { + t.Helper() + db := openTestDB(t) + if err := runSchema(db); err != nil { + t.Fatalf("migration: %v", err) + } + store := &Store{db: db} + return &Engine{ + store: store, + config: Config{}, + } +} + +// --- compileSessionPattern --- + +func TestCompileSessionPattern(t *testing.T) { + tests := []struct { + pattern string + input string + want bool + }{ + // Exact match + {"agent:abc123", "agent:abc123", true}, + {"agent:abc123", "agent:def456", false}, + // Single * — matches non-colon chars + {"agent:*", "agent:abc123", true}, + {"agent:*", "agent:abc:def", false}, // * doesn't match colons + // ** — matches everything including colons + {"cron:**", "cron:backup", true}, + {"cron:**", "cron:backup:daily", true}, + {"cron:**", "agent:abc", false}, + // Mixed + {"agent:*:sub:**", "agent:abc:sub:def", true}, + {"agent:*:sub:**", "agent:abc:sub:def:ghi", true}, + {"agent:*:sub:**", "agent:abc:def", false}, + // Empty pattern — matches nothing meaningful + {"", "", true}, + {"", "agent:abc", false}, + } + + for _, tt := range tests { + re := compileSessionPattern(tt.pattern) + if re == nil && tt.pattern != "" { + t.Fatalf("compileSessionPattern(%q) returned nil", tt.pattern) + } + if tt.pattern == "" { + continue + } + got := re.MatchString(tt.input) + if got != tt.want { + t.Errorf("compileSessionPattern(%q).Match(%q) = %v, want %v", tt.pattern, tt.input, got, tt.want) + } + } +} + +// --- Session Pattern Filtering --- + +func TestEngineShouldIgnoreSession(t *testing.T) { + eng := &Engine{ + ignorePatterns: compileSessionPatterns([]string{"cron:**", "test:*"}), + } + + tests := []struct { + key string + want bool + }{ + {"cron:backup", true}, + {"cron:backup:daily", true}, + {"test:session", true}, + {"agent:abc", false}, + {"", false}, + } + + for _, tt := range tests { + got := eng.shouldIgnoreSession(tt.key) + if got != tt.want { + t.Errorf("shouldIgnoreSession(%q) = %v, want %v", tt.key, got, tt.want) + } + } +} + +func TestEngineIsStatelessSession(t *testing.T) { + eng := &Engine{ + statelessPatterns: compileSessionPatterns([]string{"agent:*:sub:**"}), + } + + tests := []struct { + key string + want bool + }{ + {"agent:abc:sub:def", true}, + {"agent:abc:sub:def:ghi", true}, + {"agent:abc", false}, + {"cron:backup", false}, + } + + for _, tt := range tests { + got := eng.isStatelessSession(tt.key) + if got != tt.want { + t.Errorf("isStatelessSession(%q) = %v, want %v", tt.key, got, tt.want) + } + } +} + +// --- NewEngine --- + +func TestNewEngine(t *testing.T) { + dir := t.TempDir() + dbPath := filepath.Join(dir, "short.db") + + eng, err := NewEngine(Config{DBPath: dbPath}, nil) + if err != nil { + t.Fatalf("NewEngine: %v", err) + } + defer eng.Close() + + // DB file should exist + if _, pathErr := os.Stat(dbPath); os.IsNotExist(pathErr) { + t.Error("expected DB file to be created") + } + + // Store should be usable + ctx := context.Background() + conv, err := eng.store.GetOrCreateConversation(ctx, "test:session") + if err != nil { + t.Fatalf("store should work: %v", err) + } + if conv.ConversationID == 0 { + t.Error("expected valid conversation ID") + } + + // GetRetrieval should return non-nil RetrievalEngine + retrieval := eng.GetRetrieval() + if retrieval == nil { + t.Error("expected GetRetrieval to return non-nil RetrievalEngine") + } +} + +func TestNewEngineWithPatterns(t *testing.T) { + dir := t.TempDir() + dbPath := filepath.Join(dir, "short.db") + + eng, err := NewEngine(Config{ + DBPath: dbPath, + IgnoreSessionPatterns: []string{"cron:**"}, + StatelessSessionPatterns: []string{"agent:*:sub:**"}, + }, nil) + if err != nil { + t.Fatalf("NewEngine: %v", err) + } + defer eng.Close() + + if !eng.shouldIgnoreSession("cron:backup") { + t.Error("expected cron:backup to be ignored") + } + if !eng.isStatelessSession("agent:abc:sub:def") { + t.Error("expected agent:abc:sub:def to be stateless") + } +} + +// --- Ingest --- + +func TestEngineIngest(t *testing.T) { + eng := newTestEngine(t) + ctx := context.Background() + + msgs := []Message{ + {Role: "user", Content: "hello", TokenCount: 2}, + {Role: "assistant", Content: "world", TokenCount: 2}, + } + + result, err := eng.Ingest(ctx, "agent:test", msgs) + if err != nil { + t.Fatalf("Ingest: %v", err) + } + if result.MessageCount != 2 { + t.Errorf("MessageCount = %d, want 2", result.MessageCount) + } + if result.TokenCount != 4 { + t.Errorf("TokenCount = %d, want 4", result.TokenCount) + } + + // Verify messages were stored + conv, _ := eng.store.GetOrCreateConversation(ctx, "agent:test") + stored, _ := eng.store.GetMessages(ctx, conv.ConversationID, 10, 0) + if len(stored) != 2 { + t.Fatalf("stored messages = %d, want 2", len(stored)) + } + if stored[0].Content != "hello" { + t.Errorf("stored[0].Content = %q, want 'hello'", stored[0].Content) + } + + // Verify context_items were populated + items, _ := eng.store.GetContextItems(ctx, conv.ConversationID) + if len(items) != 2 { + t.Fatalf("context items = %d, want 2", len(items)) + } + if items[0].ItemType != "message" { + t.Errorf("item[0].ItemType = %q, want 'message'", items[0].ItemType) + } +} + +func TestEngineIngestIgnoresSession(t *testing.T) { + eng := newTestEngine(t) + eng.ignorePatterns = compileSessionPatterns([]string{"cron:**"}) + ctx := context.Background() + + msgs := []Message{{Role: "user", Content: "hello", TokenCount: 2}} + result, err := eng.Ingest(ctx, "cron:backup", msgs) + if err != nil { + t.Fatalf("Ingest: %v", err) + } + if result != nil { + t.Error("expected nil result for ignored session") + } + + // Verify no data was stored + conv, _ := eng.store.GetConversationBySessionKey(ctx, "cron:backup") + if conv != nil { + t.Error("expected no conversation for ignored session") + } +} + +func TestEngineIngestStatelessSession(t *testing.T) { + eng := newTestEngine(t) + eng.statelessPatterns = compileSessionPatterns([]string{"agent:*:ro"}) + ctx := context.Background() + + msgs := []Message{{Role: "user", Content: "hello", TokenCount: 2}} + result, err := eng.Ingest(ctx, "agent:abc:ro", msgs) + if err != nil { + t.Fatalf("Ingest: %v", err) + } + if result != nil { + t.Error("expected nil result for stateless session") + } +} + +func TestEngineIngestIncremental(t *testing.T) { + eng := newTestEngine(t) + ctx := context.Background() + + // First ingest + eng.Ingest(ctx, "agent:test", []Message{ + {Role: "user", Content: "msg1", TokenCount: 1}, + }) + // Second ingest — should append, not replace + eng.Ingest(ctx, "agent:test", []Message{ + {Role: "assistant", Content: "msg2", TokenCount: 1}, + }) + + conv, _ := eng.store.GetOrCreateConversation(ctx, "agent:test") + stored, _ := eng.store.GetMessages(ctx, conv.ConversationID, 10, 0) + if len(stored) != 2 { + t.Errorf("stored messages = %d, want 2", len(stored)) + } +} + +func TestEngineIngestWithParts(t *testing.T) { + eng := newTestEngine(t) + ctx := context.Background() + + msgs := []Message{ + { + Role: "assistant", + Content: "", + TokenCount: 10, + Parts: []MessagePart{ + {Type: "tool_use", Name: "read_file", Arguments: `{"path":"/tmp/test"}`, ToolCallID: "tc_123"}, + {Type: "text", Text: "here is the file content"}, + }, + }, + } + + result, err := eng.Ingest(ctx, "agent:parts-test", msgs) + if err != nil { + t.Fatalf("Ingest with parts: %v", err) + } + if result.MessageCount != 1 { + t.Errorf("MessageCount = %d, want 1", result.MessageCount) + } + + // Verify message was stored WITH parts + conv, _ := eng.store.GetOrCreateConversation(ctx, "agent:parts-test") + stored, _ := eng.store.GetMessages(ctx, conv.ConversationID, 10, 0) + if len(stored) != 1 { + t.Fatalf("stored messages = %d, want 1", len(stored)) + } + if len(stored[0].Parts) != 2 { + t.Fatalf("stored message parts = %d, want 2", len(stored[0].Parts)) + } + if stored[0].Parts[0].Type != "tool_use" { + t.Errorf("part[0].Type = %q, want tool_use", stored[0].Parts[0].Type) + } + if stored[0].Parts[0].Name != "read_file" { + t.Errorf("part[0].Name = %q, want read_file", stored[0].Parts[0].Name) + } + if stored[0].Parts[0].ToolCallID != "tc_123" { + t.Errorf("part[0].ToolCallID = %q, want tc_123", stored[0].Parts[0].ToolCallID) + } + if stored[0].Parts[1].Type != "text" { + t.Errorf("part[1].Type = %q, want text", stored[0].Parts[1].Type) + } + if stored[0].Parts[1].Text != "here is the file content" { + t.Errorf("part[1].Text = %q, want 'here is the file content'", stored[0].Parts[1].Text) + } +} + +func TestEngineIngestAssemblePreservesParts(t *testing.T) { + eng := newTestEngine(t) + ctx := context.Background() + + // Ingest a message with tool_use parts + eng.Ingest(ctx, "agent:parts-roundtrip", []Message{ + {Role: "user", Content: "list files", TokenCount: 3}, + { + Role: "assistant", + Content: "", + TokenCount: 5, + Parts: []MessagePart{ + {Type: "tool_use", Name: "bash", Arguments: `{"cmd":"ls"}`, ToolCallID: "tc_1"}, + {Type: "text", Text: "found 3 files"}, + }, + }, + }) + + // Assemble should return messages with parts intact + result, err := eng.Assemble(ctx, "agent:parts-roundtrip", AssembleInput{Budget: 1000}) + if err != nil { + t.Fatalf("Assemble: %v", err) + } + + if len(result.Messages) != 2 { + t.Fatalf("Assemble returned %d messages, want 2", len(result.Messages)) + } + + // The second message should have Parts populated + assistantMsg := result.Messages[1] + if len(assistantMsg.Parts) != 2 { + t.Fatalf("Assembled assistant message Parts = %d, want 2", len(assistantMsg.Parts)) + } + if assistantMsg.Parts[0].Type != "tool_use" { + t.Errorf("part[0].Type = %q, want tool_use", assistantMsg.Parts[0].Type) + } + if assistantMsg.Parts[0].ToolCallID != "tc_1" { + t.Errorf("part[0].ToolCallID = %q, want tc_1", assistantMsg.Parts[0].ToolCallID) + } +} + +// --- Session Mutex --- + +func TestEngineSessionMutex(t *testing.T) { + eng := newTestEngine(t) + + mu1 := eng.getSessionMutex("agent:test") + mu2 := eng.getSessionMutex("agent:test") + mu3 := eng.getSessionMutex("agent:other") + + if mu1 != mu2 { + t.Error("expected same mutex for same session key") + } + if mu1 == mu3 { + t.Error("expected different mutex for different session key") + } +} + +// --- Close --- + +func TestEngineClose(t *testing.T) { + eng := newTestEngine(t) + if err := eng.Close(); err != nil { + t.Errorf("Close: %v", err) + } +} + +// --- compileSessionPatterns (batch) --- + +func TestCompileSessionPatterns(t *testing.T) { + patterns := compileSessionPatterns([]string{"cron:**", "agent:*:ro"}) + if len(patterns) != 2 { + t.Fatalf("expected 2 patterns, got %d", len(patterns)) + } + + tests := []struct { + input string + want bool + }{ + {"cron:backup", true}, + {"agent:abc:ro", true}, + {"agent:abc:def", false}, + {"", false}, + } + + for _, tt := range tests { + matched := false + for _, p := range patterns { + if p.MatchString(tt.input) { + matched = true + break + } + } + if matched != tt.want { + t.Errorf("patterns.Match(%q) = %v, want %v", tt.input, matched, tt.want) + } + } +} + +func TestCompileSessionPatternsEmpty(t *testing.T) { + patterns := compileSessionPatterns(nil) + if len(patterns) != 0 { + t.Errorf("expected 0 patterns for nil input, got %d", len(patterns)) + } +} + +// --- Bootstrap --- + +func TestEngineBootstrap(t *testing.T) { + eng := newTestEngine(t) + ctx := context.Background() + + msgs := []Message{ + {Role: "user", Content: "hello", TokenCount: 3}, + {Role: "assistant", Content: "world", TokenCount: 3}, + {Role: "user", Content: "how are you", TokenCount: 5}, + } + + err := eng.Bootstrap(ctx, "agent:boot1", msgs) + if err != nil { + t.Fatalf("Bootstrap: %v", err) + } + + // Verify conversation was created + conv, err := eng.store.GetConversationBySessionKey(ctx, "agent:boot1") + if err != nil { + t.Fatalf("GetConversation: %v", err) + } + if conv == nil { + t.Fatal("expected conversation to exist after bootstrap") + } + + // Verify messages were stored + stored, err := eng.store.GetMessages(ctx, conv.ConversationID, 10, 0) + if err != nil { + t.Fatalf("GetMessages: %v", err) + } + if len(stored) != 3 { + t.Fatalf("expected 3 stored messages, got %d", len(stored)) + } + if stored[0].Content != "hello" { + t.Errorf("stored[0].Content = %q, want 'hello'", stored[0].Content) + } + + // Verify context_items were populated + items, err := eng.store.GetContextItems(ctx, conv.ConversationID) + if err != nil { + t.Fatalf("GetContextItems: %v", err) + } + if len(items) != 3 { + t.Fatalf("expected 3 context items, got %d", len(items)) + } +} + +func TestEngineBootstrapEmpty(t *testing.T) { + eng := newTestEngine(t) + ctx := context.Background() + + err := eng.Bootstrap(ctx, "agent:empty", nil) + if err != nil { + t.Fatalf("Bootstrap empty: %v", err) + } + + // No conversation should be created for empty messages + conv, _ := eng.store.GetConversationBySessionKey(ctx, "agent:empty") + if conv != nil { + t.Error("expected no conversation for empty bootstrap") + } +} + +func TestEngineBootstrapIdempotent(t *testing.T) { + eng := newTestEngine(t) + ctx := context.Background() + + msgs := []Message{ + {Role: "user", Content: "hello", TokenCount: 3}, + {Role: "assistant", Content: "world", TokenCount: 3}, + } + + // Bootstrap twice with same messages + eng.Bootstrap(ctx, "agent:idem", msgs) + eng.Bootstrap(ctx, "agent:idem", msgs) + + // Should still have exactly 2 messages (no duplicates) + conv, _ := eng.store.GetConversationBySessionKey(ctx, "agent:idem") + if conv == nil { + t.Fatal("expected conversation") + } + stored, _ := eng.store.GetMessages(ctx, conv.ConversationID, 10, 0) + if len(stored) != 2 { + t.Errorf("expected 2 messages (idempotent), got %d", len(stored)) + } +} + +func TestEngineBootstrapDelta(t *testing.T) { + eng := newTestEngine(t) + ctx := context.Background() + + // First bootstrap with 2 messages + msgs1 := []Message{ + {Role: "user", Content: "hello", TokenCount: 3}, + {Role: "assistant", Content: "world", TokenCount: 3}, + } + eng.Bootstrap(ctx, "agent:delta", msgs1) + + // Second bootstrap with 4 messages (2 existing + 2 new) + msgs2 := []Message{ + {Role: "user", Content: "hello", TokenCount: 3}, + {Role: "assistant", Content: "world", TokenCount: 3}, + {Role: "user", Content: "new question", TokenCount: 5}, + {Role: "assistant", Content: "new answer", TokenCount: 5}, + } + eng.Bootstrap(ctx, "agent:delta", msgs2) + + conv, _ := eng.store.GetConversationBySessionKey(ctx, "agent:delta") + if conv == nil { + t.Fatal("expected conversation") + } + stored, _ := eng.store.GetMessages(ctx, conv.ConversationID, 10, 0) + if len(stored) != 4 { + t.Errorf("expected 4 messages (delta), got %d", len(stored)) + } +} + +func TestBootstrapPopulatesContextItems(t *testing.T) { + // Bootstrap ingests messages and populates context_items + e := newTestEngine(t) + ctx := context.Background() + + messages := []Message{ + {Role: "user", Content: "hello from bootstrap test", TokenCount: 10}, + {Role: "assistant", Content: "hi there", TokenCount: 5}, + {Role: "user", Content: "how are you", TokenCount: 5}, + {Role: "assistant", Content: "doing well", TokenCount: 5}, + {Role: "user", Content: "great news", TokenCount: 5}, + {Role: "assistant", Content: "awesome", TokenCount: 5}, + {Role: "user", Content: "lets code", TokenCount: 5}, + {Role: "assistant", Content: "sure thing", TokenCount: 5}, + } + + // Bootstrap should ingest and rebuild context_items + err := e.Bootstrap(ctx, "test-bootstrap-rebuild", messages) + if err != nil { + t.Fatalf("Bootstrap: %v", err) + } + + // After bootstrap, context_items should be populated + conv, _ := e.store.GetOrCreateConversation(ctx, "test-bootstrap-rebuild") + items, err := e.store.GetContextItems(ctx, conv.ConversationID) + if err != nil { + t.Fatalf("GetContextItems: %v", err) + } + + if len(items) == 0 { + t.Error("expected context_items to be populated after Bootstrap, got 0 items") + } + + // Should have one item per message + if len(items) != len(messages) { + t.Errorf("expected %d context items, got %d", len(messages), len(items)) + } +} + +func TestBootstrapDeltaPreservesOrder(t *testing.T) { + // When Bootstrap does delta ingest, context_items should maintain + // correct order with new messages appended after anchor. + e := newTestEngine(t) + ctx := context.Background() + sessionKey := "test-bootstrap-delta-order" + + // First: bootstrap with 4 messages + initialMsgs := []Message{ + {Role: "user", Content: "msg1", TokenCount: 5}, + {Role: "assistant", Content: "msg2", TokenCount: 5}, + {Role: "user", Content: "msg3", TokenCount: 5}, + {Role: "assistant", Content: "msg4", TokenCount: 5}, + } + err := e.Bootstrap(ctx, sessionKey, initialMsgs) + if err != nil { + t.Fatalf("first Bootstrap: %v", err) + } + + conv, _ := e.store.GetOrCreateConversation(ctx, sessionKey) + items1, _ := e.store.GetContextItems(ctx, conv.ConversationID) + if len(items1) != 4 { + t.Fatalf("after first bootstrap: expected 4 items, got %d", len(items1)) + } + + // Now bootstrap again with 6 messages (4 existing + 2 new) + // The delta (msg5, msg6) should be appended + updatedMsgs := []Message{ + {Role: "user", Content: "msg1", TokenCount: 5}, + {Role: "assistant", Content: "msg2", TokenCount: 5}, + {Role: "user", Content: "msg3", TokenCount: 5}, + {Role: "assistant", Content: "msg4", TokenCount: 5}, + {Role: "user", Content: "msg5", TokenCount: 5}, + {Role: "assistant", Content: "msg6", TokenCount: 5}, + } + err = e.Bootstrap(ctx, sessionKey, updatedMsgs) + if err != nil { + t.Fatalf("second Bootstrap: %v", err) + } + + items2, _ := e.store.GetContextItems(ctx, conv.ConversationID) + if len(items2) != 6 { + t.Errorf("after delta bootstrap: expected 6 items, got %d", len(items2)) + } +} + +func TestBootstrapHistoryEditFirstMessageChanged(t *testing.T) { + // When the first message changes (anchor = -1), Bootstrap should rebuild + // from scratch without panicking (regression test for index out of range [-1]) + e := newTestEngine(t) + ctx := context.Background() + sessionKey := "test-bootstrap-history-edit" + + // First: bootstrap with some messages + initialMsgs := []Message{ + {Role: "user", Content: "original first", TokenCount: 5}, + {Role: "assistant", Content: "response", TokenCount: 5}, + {Role: "user", Content: "question", TokenCount: 5}, + } + err := e.Bootstrap(ctx, sessionKey, initialMsgs) + if err != nil { + t.Fatalf("first Bootstrap: %v", err) + } + + // Now bootstrap with completely different messages (first message changed) + // This should NOT panic - it should rebuild from scratch + editedMsgs := []Message{ + {Role: "user", Content: "DIFFERENT first message", TokenCount: 5}, + {Role: "assistant", Content: "DIFFERENT response", TokenCount: 5}, + {Role: "user", Content: "DIFFERENT question", TokenCount: 5}, + } + err = e.Bootstrap(ctx, sessionKey, editedMsgs) + if err != nil { + t.Fatalf("second Bootstrap (history edit): %v", err) + } + + conv, _ := e.store.GetOrCreateConversation(ctx, sessionKey) + stored, _ := e.store.GetMessages(ctx, conv.ConversationID, 10, 0) + + // Should have the NEW messages (history was rebuilt) + if len(stored) != 3 { + t.Errorf("expected 3 messages after history edit, got %d", len(stored)) + } + if len(stored) > 0 && stored[0].Content != "DIFFERENT first message" { + t.Errorf("first message = %q, want 'DIFFERENT first message'", stored[0].Content) + } +} + +func TestBootstrapSameContentDifferentTokenCountNoRebuild(t *testing.T) { + // Bootstrap should NOT rebuild when content is identical but TokenCount differs. + // This happens when TokenCount is re-estimated (e.g., via tokenizer.EstimateMessageTokens) + // during bootstrap, which may give slightly different values. + e := newTestEngine(t) + ctx := context.Background() + sessionKey := "test-bootstrap-token-diff" + + // First: bootstrap with some messages + initialMsgs := []Message{ + {Role: "user", Content: "hello world", TokenCount: 10}, + {Role: "assistant", Content: "hi there", TokenCount: 5}, + } + err := e.Bootstrap(ctx, sessionKey, initialMsgs) + if err != nil { + t.Fatalf("first Bootstrap: %v", err) + } + + conv, _ := e.store.GetOrCreateConversation(ctx, sessionKey) + storedBefore, _ := e.store.GetMessages(ctx, conv.ConversationID, 10, 0) + + // Second: bootstrap with SAME content but DIFFERENT TokenCount + // This should be a no-op (not rebuild) + sameContentMsgs := []Message{ + {Role: "user", Content: "hello world", TokenCount: 999}, // Different token count! + {Role: "assistant", Content: "hi there", TokenCount: 888}, // Different token count! + } + err = e.Bootstrap(ctx, sessionKey, sameContentMsgs) + if err != nil { + t.Fatalf("second Bootstrap: %v", err) + } + + storedAfter, _ := e.store.GetMessages(ctx, conv.ConversationID, 10, 0) + + // Should have same number of messages (no rebuild) + if len(storedAfter) != len(storedBefore) { + t.Errorf("expected %d messages (no rebuild), got %d", len(storedBefore), len(storedAfter)) + } + + // Message IDs should be the same (no delete+re-ingest) + for i := range storedBefore { + if storedBefore[i].ID != storedAfter[i].ID { + t.Errorf("message %d ID changed: before=%d, after=%d (should be no-op)", + i, storedBefore[i].ID, storedAfter[i].ID) + } + } +} + +// --- Session Mutex --- + +func TestEngineSessionMutexSharded(t *testing.T) { + eng := newTestEngine(t) + + // Same session key should always return the same mutex (deterministic hash) + mu1 := eng.getSessionMutex("agent:test") + mu2 := eng.getSessionMutex("agent:test") + if mu1 != mu2 { + t.Error("expected same mutex for same session key") + } + + // Different session keys may share the same shard (hash collision) + // This is expected behavior - we just need bounded memory, not unique locks + mu3 := eng.getSessionMutex("agent:other") + + // Both mutexes should be valid and usable + mu1.Lock() + mu1.Unlock() + mu3.Lock() + mu3.Unlock() +} + +func TestEngineSessionMutexBoundedMemory(t *testing.T) { + // Verify that session mutexes use bounded memory (256 shards) + eng := newTestEngine(t) + + // Get mutexes for many different sessions + seen := make(map[*sync.Mutex]bool) + for i := 0; i < 1000; i++ { + sessionKey := fmt.Sprintf("agent:session-%d", i) + mu := eng.getSessionMutex(sessionKey) + seen[mu] = true + } + + // With 256 shards and 1000 sessions, we should see at most 256 unique mutexes + // (likely fewer due to hash collisions) + if len(seen) > 256 { + t.Errorf("expected at most 256 unique mutexes (shards), got %d", len(seen)) + } +} + +func TestEngineSessionMutexConsistentHash(t *testing.T) { + // Same session key should always hash to the same shard + eng := newTestEngine(t) + + sessionKey := "agent:consistent-hash-test" + mu1 := eng.getSessionMutex(sessionKey) + mu2 := eng.getSessionMutex(sessionKey) + mu3 := eng.getSessionMutex(sessionKey) + + if mu1 != mu2 || mu2 != mu3 { + t.Error("hash function should be deterministic - same key must map to same shard") + } +} + +// --- Summary Role --- + +func TestAssemblerSummaryRoleNotUser(t *testing.T) { + // Summaries should use "system" role, not "user" + eng := newTestEngine(t) + ctx := context.Background() + + // Ingest messages + eng.Ingest(ctx, "agent:summary-role-test", []Message{ + {Role: "user", Content: "hello", TokenCount: 5}, + {Role: "assistant", Content: "world", TokenCount: 5}, + }) + + conv, _ := eng.store.GetOrCreateConversation(ctx, "agent:summary-role-test") + + // Create a summary and add it to context + sum, err := eng.store.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, + Content: "Test summary content", + TokenCount: 10, + Kind: SummaryKindCondensed, + Depth: 1, + }) + if err != nil { + t.Fatalf("CreateSummary: %v", err) + } + eng.store.AppendContextSummary(ctx, conv.ConversationID, sum.SummaryID) + + // Assemble and check summary message role + result, err := eng.Assemble(ctx, "agent:summary-role-test", AssembleInput{Budget: 1000}) + if err != nil { + t.Fatalf("Assemble: %v", err) + } + + // Find the summary message (should have XML content with ) + for _, msg := range result.Messages { + if strings.Contains(msg.Content, "= 5 + // This tests the bug: when depth=2 is missing, the loop breaks and depth=3 is never checked + // Need > FreshTailCount(32) summaries so they are not all in fresh tail + // Depth 0: 3 summaries (not enough), Depth 1: 3 summaries (not enough) + // Depth 2: 0 summaries (missing), Depth 3: 40 summaries (enough) + depths := []int{0, 0, 0, 1, 1, 1} + for i := 0; i < 40; i++ { + depths = append(depths, 3) + } + now := time.Now().UTC() + + for i, depth := range depths { + sum, createErr := e.store.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, + Kind: SummaryKindLeaf, + Depth: depth, + Content: fmt.Sprintf("summary depth %d #%d", depth, i), + TokenCount: 10, + EarliestAt: &now, + LatestAt: &now, + }) + if createErr != nil { + t.Fatalf("CreateSummary: %v", createErr) + } + // Add to context items (not in fresh tail) + if appendErr := e.store.AppendContextSummary(ctx, conv.ConversationID, sum.SummaryID); appendErr != nil { + t.Fatalf("AppendContextSummary: %v", appendErr) + } + } + + // Initialize compaction engine (lazy init) + e.initCompactionOnce() + + // Call selectShallowestCondensationCandidate + candidates, err := e.compaction.selectShallowestCondensationCandidate(ctx, conv.ConversationID, false) + if err != nil { + t.Fatalf("selectShallowestCondensationCandidate: %v", err) + } + + // Should find depth=0 (shallowest) with 5 summaries + if candidates == nil { + t.Fatal("expected candidates, got nil") + } + if len(candidates) < CondensedMinFanout { + t.Errorf("expected at least %d candidates, got %d", CondensedMinFanout, len(candidates)) + } + + // Verify all returned summaries have the same depth + if len(candidates) > 0 { + expectedDepth := candidates[0].Depth + for _, c := range candidates[1:] { + if c.Depth != expectedDepth { + t.Errorf("candidates have mixed depths: %d vs %d", expectedDepth, c.Depth) + } + } + } +} diff --git a/pkg/seahorse/short_retrieval.go b/pkg/seahorse/short_retrieval.go new file mode 100644 index 000000000..f7d6bf691 --- /dev/null +++ b/pkg/seahorse/short_retrieval.go @@ -0,0 +1,212 @@ +package seahorse + +import ( + "context" + "fmt" + "regexp" + "strconv" + "strings" + "time" +) + +// ParseLastDuration parses a "last" duration string like "6h", "7d", "2w", "1m". +// Returns the duration and nil error, or zero and error if invalid. +func ParseLastDuration(s string) (time.Duration, error) { + if s == "" { + return 0, fmt.Errorf("empty duration") + } + + re := regexp.MustCompile(`^(\d+)([hdwm])$`) + matches := re.FindStringSubmatch(s) + if matches == nil { + return 0, fmt.Errorf("invalid duration format: %q (use format like 6h, 7d, 2w, 1m)", s) + } + + value, _ := strconv.Atoi(matches[1]) + unit := matches[2] + + switch unit { + case "h": + return time.Duration(value) * time.Hour, nil + case "d": + return time.Duration(value) * 24 * time.Hour, nil + case "w": + return time.Duration(value) * 7 * 24 * time.Hour, nil + case "m": + return time.Duration(value) * 30 * 24 * time.Hour, nil + default: + return 0, fmt.Errorf("unknown unit: %q", unit) + } +} + +// GrepInput controls search across summaries and messages. +type GrepInput struct { + Pattern string `json:"pattern"` + Scope string `json:"scope,omitempty"` // "both" (default), "summary", or "message" + Role string `json:"role,omitempty"` // "user", "assistant", or "" (all) + AllConversations bool `json:"allConversations,omitempty"` + Since *time.Time `json:"since,omitempty"` + Before *time.Time `json:"before,omitempty"` + Last string `json:"last,omitempty"` // shortcut: "6h", "7d", "2w", "1m" + Limit int `json:"limit,omitempty"` +} + +// GrepResult contains search results. +type GrepResult struct { + Success bool `json:"success"` + Summaries []GrepSummaryResult `json:"summaries"` + Messages []GrepMessageResult `json:"messages"` + TotalSummaries int `json:"totalSummaries"` + TotalMessages int `json:"totalMessages"` + Hint string `json:"hint,omitempty"` +} + +// GrepSummaryResult is a summary match from grep. +type GrepSummaryResult struct { + ID string `json:"id"` + Content string `json:"content"` + Depth int `json:"depth"` + Kind SummaryKind `json:"kind"` + ConversationID int64 `json:"conversationId"` + // Rank is the bm25 relevance score (negative value, closer to 0 = better match). + // Examples: -0.5 = excellent match, -2.0 = good match, -10.0 = partial match. + Rank float64 `json:"rank,omitempty"` +} + +// GrepMessageResult is a message match from grep. +type GrepMessageResult struct { + ID int64 `json:"id,string"` + Snippet string `json:"snippet"` + Role string `json:"role"` + ConversationID int64 `json:"conversationId"` + Rank float64 `json:"rank,omitempty"` // Relevance score (lower = better match) +} + +// ExpandMessagesResult contains expanded messages. +type ExpandMessagesResult struct { + Messages []Message `json:"messages"` + TokenCount int `json:"tokenCount"` +} + +// Grep searches summaries and messages for matching content. +func (r *RetrievalEngine) Grep(ctx context.Context, input GrepInput) (*GrepResult, error) { + if input.Pattern == "" { + return nil, fmt.Errorf("grep: pattern is required") + } + + limit := input.Limit + if limit == 0 { + limit = 20 + } + + // Handle Last parameter: convert to Since + since := input.Since + if input.Last != "" { + dur, err := ParseLastDuration(input.Last) + if err != nil { + return nil, fmt.Errorf("grep: invalid last: %w", err) + } + t := time.Now().UTC().Add(-dur) + since = &t + } + + // Auto-detect mode: use LIKE if pattern contains %, otherwise full-text + mode := "" + if strings.Contains(input.Pattern, "%") { + mode = "like" + } + + searchInput := SearchInput{ + Pattern: input.Pattern, + Mode: mode, + Role: input.Role, + AllConversations: input.AllConversations, + Since: since, + Before: input.Before, + Limit: limit, + } + + result := &GrepResult{ + Success: true, + Summaries: make([]GrepSummaryResult, 0), + Messages: make([]GrepMessageResult, 0), + TotalSummaries: 0, + TotalMessages: 0, + } + + // Determine scope + scope := input.Scope + if scope == "" { + scope = "both" + } + + // Search summaries if requested + if scope == "both" || scope == "summary" { + sumResults, err := r.store.SearchSummaries(ctx, searchInput) + if err != nil { + return nil, fmt.Errorf("search summaries: %w", err) + } + for _, sr := range sumResults { + if sr.SummaryID != "" { + result.Summaries = append(result.Summaries, GrepSummaryResult{ + ID: sr.SummaryID, + Content: sr.Content, + Depth: sr.Depth, + Kind: sr.Kind, + ConversationID: sr.ConversationID, + Rank: sr.Rank, + }) + } + } + if len(sumResults) > 0 { + result.TotalSummaries = sumResults[0].TotalCount + } + } + + // Search messages if requested + if scope == "both" || scope == "message" { + msgResults, err := r.store.SearchMessages(ctx, searchInput) + if err != nil { + return nil, fmt.Errorf("search messages: %w", err) + } + for _, sr := range msgResults { + if sr.MessageID > 0 { + result.Messages = append(result.Messages, GrepMessageResult{ + ID: sr.MessageID, + Snippet: sr.Snippet, + Role: sr.Role, + ConversationID: sr.ConversationID, + Rank: sr.Rank, + }) + } + } + if len(msgResults) > 0 { + result.TotalMessages = msgResults[0].TotalCount + } + } + + // Add hint if no results + if len(result.Summaries) == 0 && len(result.Messages) == 0 { + result.Hint = "No matches. Try: %keyword% for fuzzy search, or all_conversations: true" + } + + return result, nil +} + +// ExpandMessages retrieves full message content by IDs. +func (r *RetrievalEngine) ExpandMessages(ctx context.Context, messageIDs []int64) (*ExpandMessagesResult, error) { + result := &ExpandMessagesResult{ + Messages: make([]Message, 0, len(messageIDs)), + } + + for _, msgID := range messageIDs { + msg, err := r.store.GetMessageByID(ctx, msgID) + if err != nil { + continue + } + result.Messages = append(result.Messages, *msg) + result.TokenCount += msg.TokenCount + } + + return result, nil +} diff --git a/pkg/seahorse/short_retrieval_test.go b/pkg/seahorse/short_retrieval_test.go new file mode 100644 index 000000000..9d9bc3640 --- /dev/null +++ b/pkg/seahorse/short_retrieval_test.go @@ -0,0 +1,362 @@ +package seahorse + +import ( + "context" + "fmt" + "testing" + "time" +) + +// --- Retrieval Tests --- + +func newTestRetrieval(t *testing.T) (*RetrievalEngine, *Store, int64) { + t.Helper() + s := openTestStore(t) + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "test:retrieval") + return &RetrievalEngine{store: s}, s, conv.ConversationID +} + +func TestRetrievalGrepSummaries(t *testing.T) { + r, s, convID := newTestRetrieval(t) + ctx := context.Background() + + s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "数据库连接配置说明", + TokenCount: 50, + }) + s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "API endpoint documentation", + TokenCount: 50, + }) + + // FTS5 search (trigram, needs >= 3 chars) + results, err := r.Grep(ctx, GrepInput{ + Pattern: "数据库连", + }) + if err != nil { + t.Fatalf("Grep: %v", err) + } + if len(results.Summaries) == 0 { + t.Error("expected at least 1 FTS result") + } + + // LIKE search with wildcard + results, err = r.Grep(ctx, GrepInput{ + Pattern: "%endpoint%", + }) + if err != nil { + t.Fatalf("Grep LIKE: %v", err) + } + if len(results.Summaries) == 0 { + t.Error("expected at least 1 LIKE result") + } +} + +func TestRetrievalGrepMessages(t *testing.T) { + r, s, convID := newTestRetrieval(t) + ctx := context.Background() + + s.AddMessage(ctx, convID, "user", "find this message about testing", 5) + s.AddMessage(ctx, convID, "user", "unrelated content here", 5) + + results, err := r.Grep(ctx, GrepInput{ + Pattern: "testing", + }) + if err != nil { + t.Fatalf("Grep: %v", err) + } + if len(results.Messages) == 0 { + t.Error("expected at least 1 result for 'testing'") + } +} + +func TestRetrievalExpandMessages(t *testing.T) { + r, s, convID := newTestRetrieval(t) + ctx := context.Background() + + msg, _ := s.AddMessage(ctx, convID, "user", "expand this message", 10) + + result, err := r.ExpandMessages(ctx, []int64{msg.ID}) + if err != nil { + t.Fatalf("ExpandMessages: %v", err) + } + if len(result.Messages) != 1 { + t.Errorf("Messages = %d, want 1", len(result.Messages)) + } + if result.Messages[0].Content != "expand this message" { + t.Errorf("Content = %q, want 'expand this message'", result.Messages[0].Content) + } +} + +func TestRetrievalExpandMultipleMessages(t *testing.T) { + r, s, convID := newTestRetrieval(t) + ctx := context.Background() + + msg1, _ := s.AddMessage(ctx, convID, "user", "first message", 10) + msg2, _ := s.AddMessage(ctx, convID, "assistant", "second message", 10) + msg3, _ := s.AddMessage(ctx, convID, "user", "third message", 10) + + result, err := r.ExpandMessages(ctx, []int64{msg1.ID, msg2.ID, msg3.ID}) + if err != nil { + t.Fatalf("ExpandMessages: %v", err) + } + if len(result.Messages) != 3 { + t.Errorf("Messages = %d, want 3", len(result.Messages)) + } + if result.TokenCount != 30 { + t.Errorf("TokenCount = %d, want 30", result.TokenCount) + } +} + +func TestRetrievalGrepWithTimeFilter(t *testing.T) { + r, s, convID := newTestRetrieval(t) + ctx := context.Background() + + now := time.Now().UTC() + before := now.Add(-2 * time.Hour) + + // Create messages at different times + s.AddMessage(ctx, convID, "user", "old message about auth", 5) + s.AddMessage(ctx, convID, "user", "recent message about auth", 5) + + // Search with time filter + results, err := r.Grep(ctx, GrepInput{ + Pattern: "auth", + Since: &before, + }) + if err != nil { + t.Fatalf("Grep: %v", err) + } + _ = results // Just verify no error +} + +func TestRetrievalGrepAllConversations(t *testing.T) { + r, s, _ := newTestRetrieval(t) + ctx := context.Background() + + // Create another conversation + conv2, _ := s.GetOrCreateConversation(ctx, "test:retrieval2") + + // Add messages to both + s.AddMessage(ctx, conv2.ConversationID, "user", "unique keyword xyz", 5) + + // Search all conversations + results, err := r.Grep(ctx, GrepInput{ + Pattern: "xyz", + AllConversations: true, + }) + if err != nil { + t.Fatalf("Grep: %v", err) + } + if len(results.Messages) == 0 { + t.Error("expected to find message in other conversation") + } +} + +// --- Last Duration Parsing Tests --- + +func TestParseLastDuration(t *testing.T) { + tests := []struct { + input string + wantDur time.Duration + wantErr bool + }{ + {"6h", 6 * time.Hour, false}, + {"1d", 24 * time.Hour, false}, + {"7d", 7 * 24 * time.Hour, false}, + {"2w", 14 * 24 * time.Hour, false}, + {"1m", 30 * 24 * time.Hour, false}, // month = 30 days + {"3m", 90 * 24 * time.Hour, false}, + {"", 0, true}, + {"invalid", 0, true}, + {"5x", 0, true}, // unknown unit + } + + for _, tt := range tests { + t.Run(tt.input, func(t *testing.T) { + got, err := ParseLastDuration(tt.input) + if tt.wantErr { + if err == nil { + t.Error("expected error, got nil") + } + } else { + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if got != tt.wantDur { + t.Errorf("ParseLastDuration(%q) = %v, want %v", tt.input, got, tt.wantDur) + } + } + }) + } +} + +// --- Role Filter Tests --- + +func TestRetrievalGrepRoleFilter(t *testing.T) { + r, s, convID := newTestRetrieval(t) + ctx := context.Background() + + s.AddMessage(ctx, convID, "user", "user message about alpha", 5) + s.AddMessage(ctx, convID, "assistant", "assistant reply about alpha", 5) + s.AddMessage(ctx, convID, "user", "another user message", 5) + + // Search all roles + allResults, err := r.Grep(ctx, GrepInput{ + Pattern: "alpha", + }) + if err != nil { + t.Fatalf("Grep: %v", err) + } + if len(allResults.Messages) != 2 { + t.Errorf("expected 2 messages, got %d", len(allResults.Messages)) + } + + // Search user only + userResults, err := r.Grep(ctx, GrepInput{ + Pattern: "alpha", + Role: "user", + }) + if err != nil { + t.Fatalf("Grep: %v", err) + } + if len(userResults.Messages) != 1 { + t.Errorf("expected 1 user message, got %d", len(userResults.Messages)) + } + if userResults.Messages[0].Role != "user" { + t.Errorf("expected role=user, got %s", userResults.Messages[0].Role) + } + + // Search assistant only + assistantResults, err := r.Grep(ctx, GrepInput{ + Pattern: "alpha", + Role: "assistant", + }) + if err != nil { + t.Fatalf("Grep: %v", err) + } + if len(assistantResults.Messages) != 1 { + t.Errorf("expected 1 assistant message, got %d", len(assistantResults.Messages)) + } +} + +// --- Last Parameter Tests --- + +func TestRetrievalGrepWithLast(t *testing.T) { + r, s, convID := newTestRetrieval(t) + ctx := context.Background() + + // Add messages (we can't control timestamps in SQLite easily, + // but we can verify the parameter is parsed correctly) + s.AddMessage(ctx, convID, "user", "recent message about testing", 5) + + // Test that Last parameter is converted to Since + results, err := r.Grep(ctx, GrepInput{ + Pattern: "testing", + Last: "1d", // last 1 day + }) + if err != nil { + t.Fatalf("Grep: %v", err) + } + // Should still find the message since it's recent + if len(results.Messages) == 0 { + t.Error("expected to find recent message") + } +} + +// TestRetrievalGrepRoleFilterWithSummaries tests that role filter works when +// searching both summaries and messages (summaries don't have role column). +func TestRetrievalGrepRoleFilterWithSummaries(t *testing.T) { + r, s, convID := newTestRetrieval(t) + ctx := context.Background() + + // Create a summary (no role column) + s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "summary about testing", + TokenCount: 50, + }) + + // Add messages with different roles + s.AddMessage(ctx, convID, "user", "user message about testing", 5) + s.AddMessage(ctx, convID, "assistant", "assistant reply about testing", 5) + + // Search with role filter and scope=both (default), using LIKE mode (%) + // This should NOT error even though summaries don't have role column + bothResults, err := r.Grep(ctx, GrepInput{ + Pattern: "%testing%", // LIKE mode to trigger the bug + Role: "user", + Scope: "both", + }) + if err != nil { + t.Fatalf("Grep with role and scope=both: %v", err) + } + + // Should only return user messages, not summaries or assistant messages + if len(bothResults.Messages) != 1 { + t.Errorf("expected 1 user message, got %d", len(bothResults.Messages)) + } + if len(bothResults.Messages) > 0 && bothResults.Messages[0].Role != "user" { + t.Errorf("expected role=user, got %s", bothResults.Messages[0].Role) + } + + // Summaries should be empty since they don't have roles to filter + // (or we could return all summaries - either is acceptable) +} + +// TestRetrievalGrepTotalCounts tests that grep returns total counts. +func TestRetrievalGrepTotalCounts(t *testing.T) { + r, s, convID := newTestRetrieval(t) + ctx := context.Background() + + // Create 3 summaries + for i := 0; i < 3; i++ { + s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: convID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: fmt.Sprintf("summary about testing %d", i), + TokenCount: 50, + }) + } + + // Add 5 messages + for i := 0; i < 5; i++ { + s.AddMessage(ctx, convID, "user", fmt.Sprintf("message about testing %d", i), 5) + } + + // Search with limit smaller than total + results, err := r.Grep(ctx, GrepInput{ + Pattern: "%testing%", // LIKE mode + Scope: "both", + Limit: 2, + }) + if err != nil { + t.Fatalf("Grep: %v", err) + } + + // Should return limited results + if len(results.Summaries) > 2 { + t.Errorf("expected at most 2 summaries, got %d", len(results.Summaries)) + } + if len(results.Messages) > 2 { + t.Errorf("expected at most 2 messages, got %d", len(results.Messages)) + } + + // But total counts should reflect all matches + if results.TotalSummaries != 3 { + t.Errorf("expected TotalSummaries=3, got %d", results.TotalSummaries) + } + if results.TotalMessages != 5 { + t.Errorf("expected TotalMessages=5, got %d", results.TotalMessages) + } +} diff --git a/pkg/seahorse/store.go b/pkg/seahorse/store.go new file mode 100644 index 000000000..3d85c7b9c --- /dev/null +++ b/pkg/seahorse/store.go @@ -0,0 +1,1532 @@ +package seahorse + +import ( + "context" + "database/sql" + "fmt" + "strings" + "time" +) + +// Store provides SQLite storage for seahorse. +type Store struct { + db *sql.DB +} + +// CreateSummaryInput holds parameters for creating a summary. +type CreateSummaryInput struct { + ConversationID int64 + Kind SummaryKind + Depth int + Content string + TokenCount int + EarliestAt *time.Time + LatestAt *time.Time + DescendantCount int + DescendantTokenCount int + SourceMessageTokens int + Model string + ParentIDs []string // For condensed: child summary IDs being condensed +} + +// --- Conversation Operations --- + +// GetOrCreateConversation returns the conversation for a sessionKey, creating if needed. +func (s *Store) GetOrCreateConversation(ctx context.Context, sessionKey string) (*Conversation, error) { + // Try to get first + conv, err := s.GetConversationBySessionKey(ctx, sessionKey) + if err != nil { + return nil, err + } + if conv != nil { + return conv, nil + } + + // Create + result, err := s.db.ExecContext(ctx, + "INSERT INTO conversations (session_key) VALUES (?)", + sessionKey, + ) + if err != nil { + // Race: another goroutine may have inserted + if isUniqueViolation(err) { + return s.GetConversationBySessionKey(ctx, sessionKey) + } + return nil, fmt.Errorf("create conversation: %w", err) + } + id, _ := result.LastInsertId() + return &Conversation{ + ConversationID: id, + SessionKey: sessionKey, + }, nil +} + +// GetConversationBySessionKey retrieves a conversation by session key. +func (s *Store) GetConversationBySessionKey(ctx context.Context, sessionKey string) (*Conversation, error) { + var conv Conversation + var createdAt, updatedAt string + err := s.db.QueryRowContext(ctx, + "SELECT conversation_id, session_key, created_at, updated_at FROM conversations WHERE session_key = ?", + sessionKey, + ).Scan(&conv.ConversationID, &conv.SessionKey, &createdAt, &updatedAt) + if err == sql.ErrNoRows { + return nil, nil + } + if err != nil { + return nil, fmt.Errorf("get conversation by session key: %w", err) + } + conv.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt) + conv.UpdatedAt, _ = time.Parse("2006-01-02 15:04:05", updatedAt) + return &conv, nil +} + +// GetSessionStatus returns status for a specific session. +func (s *Store) GetSessionStatus(ctx context.Context, sessionKey string) (*SessionStatus, error) { + conv, err := s.GetConversationBySessionKey(ctx, sessionKey) + if err != nil { + return nil, err + } + if conv == nil { + return nil, nil + } + + msgCount, _ := s.GetMessageCount(ctx, conv.ConversationID) + sumCount, _ := s.getSummaryCount(ctx, conv.ConversationID) + tokenCount, _ := s.GetContextTokenCount(ctx, conv.ConversationID) + + oldest, newest, _ := s.getMessageTimeRange(ctx, conv.ConversationID) + + return &SessionStatus{ + SessionKey: conv.SessionKey, + ConversationID: conv.ConversationID, + Messages: msgCount, + TotalTokens: tokenCount, + Summaries: sumCount, + OldestAt: oldest, + NewestAt: newest, + }, nil +} + +// GetAllSessionStatuses returns status for all sessions. +func (s *Store) GetAllSessionStatuses(ctx context.Context) ([]SessionStatus, error) { + rows, err := s.db.QueryContext(ctx, "SELECT session_key FROM conversations") + if err != nil { + return nil, fmt.Errorf("list sessions: %w", err) + } + defer rows.Close() + + var statuses []SessionStatus + for rows.Next() { + var sessionKey string + if err := rows.Scan(&sessionKey); err != nil { + continue + } + status, err := s.GetSessionStatus(ctx, sessionKey) + if err != nil { + continue + } + if status != nil { + statuses = append(statuses, *status) + } + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("iterate sessions: %w", err) + } + return statuses, nil +} + +func (s *Store) getSummaryCount(ctx context.Context, convID int64) (int, error) { + var count int + err := s.db.QueryRowContext(ctx, + "SELECT COUNT(*) FROM summaries WHERE conversation_id = ?", + convID, + ).Scan(&count) + return count, err +} + +func (s *Store) getMessageTimeRange(ctx context.Context, convID int64) (time.Time, time.Time, error) { + var minTime, maxTime string + err := s.db.QueryRowContext(ctx, + "SELECT MIN(created_at), MAX(created_at) FROM messages WHERE conversation_id = ?", + convID, + ).Scan(&minTime, &maxTime) + if err != nil || minTime == "" { + return time.Time{}, time.Time{}, err + } + oldest, _ := time.Parse("2006-01-02 15:04:05", minTime) + newest, _ := time.Parse("2006-01-02 15:04:05", maxTime) + return oldest, newest, nil +} + +// --- Message Operations --- + +// AddMessage appends a message to a conversation. +func (s *Store) AddMessage(ctx context.Context, convID int64, role, content string, tokenCount int) (*Message, error) { + result, err := s.db.ExecContext(ctx, + "INSERT INTO messages (conversation_id, role, content, token_count) VALUES (?, ?, ?, ?)", + convID, role, content, tokenCount, + ) + if err != nil { + return nil, fmt.Errorf("add message: %w", err) + } + id, _ := result.LastInsertId() + return &Message{ + ID: id, + ConversationID: convID, + Role: role, + Content: content, + TokenCount: tokenCount, + }, nil +} + +// partsToReadableContent derives a readable text summary from message parts. +// This ensures FTS5 indexing and summary formatting can access tool call information. +func partsToReadableContent(parts []MessagePart) string { + var b strings.Builder + for i, p := range parts { + if i > 0 { + b.WriteString("\n") + } + switch p.Type { + case "text": + b.WriteString(p.Text) + case "tool_use": + fmt.Fprintf(&b, "[tool_use: %s, args: %s]", p.Name, p.Arguments) + case "tool_result": + fmt.Fprintf(&b, "[tool_result for %s: %s]", p.ToolCallID, p.Text) + case "media": + fmt.Fprintf(&b, "[media: %s (%s)]", p.MediaURI, p.MimeType) + default: + if p.Text != "" { + b.WriteString(p.Text) + } + } + } + return b.String() +} + +// AddMessageWithParts adds a message with structured parts. +func (s *Store) AddMessageWithParts( + ctx context.Context, + convID int64, + role string, + parts []MessagePart, + tokenCount int, +) (*Message, error) { + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return nil, fmt.Errorf("begin tx: %w", err) + } + defer tx.Rollback() + + // Derive readable content from Parts for FTS5 indexing and summary formatting + readableContent := partsToReadableContent(parts) + + result, err := tx.ExecContext(ctx, + "INSERT INTO messages (conversation_id, role, content, token_count) VALUES (?, ?, ?, ?)", + convID, role, readableContent, tokenCount, + ) + if err != nil { + return nil, fmt.Errorf("add message: %w", err) + } + msgID, _ := result.LastInsertId() + + for i, p := range parts { + _, err = tx.ExecContext( + ctx, + `INSERT INTO message_parts (message_id, type, text, name, arguments, tool_call_id, media_uri, mime_type, ordinal) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, + msgID, + p.Type, + p.Text, + p.Name, + p.Arguments, + p.ToolCallID, + p.MediaURI, + p.MimeType, + i, + ) + if err != nil { + return nil, fmt.Errorf("add message part %d: %w", i, err) + } + } + if err := tx.Commit(); err != nil { + return nil, fmt.Errorf("commit: %w", err) + } + + // Return message with parts + msg := &Message{ + ID: msgID, + ConversationID: convID, + Role: role, + TokenCount: tokenCount, + Parts: make([]MessagePart, len(parts)), + } + for i, p := range parts { + p.MessageID = msgID + msg.Parts[i] = p + } + return msg, nil +} + +// GetMessages retrieves messages for a conversation. +func (s *Store) GetMessages(ctx context.Context, convID int64, limit int, beforeID int64) ([]Message, error) { + query := "SELECT message_id, conversation_id, role, content, token_count, created_at FROM messages WHERE conversation_id = ?" + args := []any{convID} + if beforeID > 0 { + query += " AND message_id < ?" + args = append(args, beforeID) + } + query += " ORDER BY message_id ASC" + if limit > 0 { + query += " LIMIT ?" + args = append(args, limit) + } + + rows, err := s.db.QueryContext(ctx, query, args...) + if err != nil { + return nil, fmt.Errorf("get messages: %w", err) + } + defer rows.Close() + + var msgs []Message + for rows.Next() { + var msg Message + var createdAt string + if err := rows.Scan( + &msg.ID, + &msg.ConversationID, + &msg.Role, + &msg.Content, + &msg.TokenCount, + &createdAt, + ); err != nil { + return nil, err + } + msg.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt) + msgs = append(msgs, msg) + } + if err := rows.Err(); err != nil { + return nil, err + } + + // Load parts for all messages + for i := range msgs { + parts, err := s.loadMessageParts(ctx, msgs[i].ID) + if err != nil { + return nil, err + } + msgs[i].Parts = parts + } + + return msgs, nil +} + +// GetMessageCount returns total message count for a conversation. +func (s *Store) GetMessageCount(ctx context.Context, convID int64) (int, error) { + var count int + err := s.db.QueryRowContext(ctx, + "SELECT count(*) FROM messages WHERE conversation_id = ?", convID, + ).Scan(&count) + return count, err +} + +// GetMessageByID retrieves a single message by ID. +func (s *Store) GetMessageByID(ctx context.Context, messageID int64) (*Message, error) { + var msg Message + var createdAt string + err := s.db.QueryRowContext(ctx, + "SELECT message_id, conversation_id, role, content, token_count, created_at FROM messages WHERE message_id = ?", + messageID, + ).Scan(&msg.ID, &msg.ConversationID, &msg.Role, &msg.Content, &msg.TokenCount, &createdAt) + if err == sql.ErrNoRows { + return nil, fmt.Errorf("message %d not found", messageID) + } + if err != nil { + return nil, err + } + msg.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt) + msg.Parts, _ = s.loadMessageParts(ctx, msg.ID) + return &msg, nil +} + +func (s *Store) loadMessageParts(ctx context.Context, msgID int64) ([]MessagePart, error) { + rows, err := s.db.QueryContext(ctx, + `SELECT part_id, message_id, type, text, name, arguments, tool_call_id, media_uri, mime_type + FROM message_parts WHERE message_id = ? ORDER BY ordinal`, + msgID, + ) + if err != nil { + return nil, err + } + defer rows.Close() + + var parts []MessagePart + for rows.Next() { + var p MessagePart + if err := rows.Scan(&p.ID, &p.MessageID, &p.Type, &p.Text, &p.Name, &p.Arguments, + &p.ToolCallID, &p.MediaURI, &p.MimeType); err != nil { + return nil, err + } + parts = append(parts, p) + } + if err := rows.Err(); err != nil { + return nil, err + } + return parts, nil +} + +// --- Summary Operations --- + +// CreateSummary creates a new summary and indexes it in FTS5. +func (s *Store) CreateSummary(ctx context.Context, input CreateSummaryInput) (*Summary, error) { + // Generate summary ID + now := time.Now().UTC() + summaryID := generateSummaryID(input.Content, now) + + var earliestAt, latestAt sql.NullString + if input.EarliestAt != nil { + earliestAt = sql.NullString{String: input.EarliestAt.Format(time.RFC3339), Valid: true} + } + if input.LatestAt != nil { + latestAt = sql.NullString{String: input.LatestAt.Format(time.RFC3339), Valid: true} + } + + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return nil, fmt.Errorf("begin tx: %w", err) + } + defer tx.Rollback() + + _, err = tx.ExecContext(ctx, + `INSERT INTO summaries (summary_id, conversation_id, kind, depth, content, token_count, + earliest_at, latest_at, descendant_count, descendant_token_count, + source_message_token_count, model) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, + summaryID, input.ConversationID, string(input.Kind), input.Depth, + input.Content, input.TokenCount, + earliestAt, latestAt, + input.DescendantCount, input.DescendantTokenCount, + input.SourceMessageTokens, input.Model, + ) + if err != nil { + return nil, fmt.Errorf("insert summary: %w", err) + } + + // FTS trigger will fire automatically for summaries table insert + + // Link parent summaries (DAG edges) for condensed summaries + for _, parentID := range input.ParentIDs { + _, err = tx.ExecContext(ctx, + "INSERT INTO summary_parents (summary_id, parent_summary_id) VALUES (?, ?)", + summaryID, parentID, + ) + if err != nil { + return nil, fmt.Errorf("link parent %s: %w", parentID, err) + } + } + + if err := tx.Commit(); err != nil { + return nil, fmt.Errorf("commit: %w", err) + } + + return &Summary{ + SummaryID: summaryID, + ConversationID: input.ConversationID, + Kind: input.Kind, + Depth: input.Depth, + Content: input.Content, + TokenCount: input.TokenCount, + EarliestAt: input.EarliestAt, + LatestAt: input.LatestAt, + DescendantCount: input.DescendantCount, + DescendantTokenCount: input.DescendantTokenCount, + SourceMessageTokenCount: input.SourceMessageTokens, + Model: input.Model, + CreatedAt: now, + }, nil +} + +// GetSummary retrieves a summary by ID. +func (s *Store) GetSummary(ctx context.Context, summaryID string) (*Summary, error) { + return s.scanSummary(ctx, "WHERE summary_id = ?", summaryID) +} + +// GetSummariesByConversation retrieves all summaries for a conversation. +func (s *Store) GetSummariesByConversation(ctx context.Context, convID int64) ([]Summary, error) { + rows, err := s.db.QueryContext(ctx, + `SELECT summary_id, conversation_id, kind, depth, content, token_count, + earliest_at, latest_at, descendant_count, descendant_token_count, + source_message_token_count, model, created_at + FROM summaries WHERE conversation_id = ? ORDER BY created_at`, + convID, + ) + if err != nil { + return nil, err + } + defer rows.Close() + return s.scanSummaries(rows) +} + +// GetSummaryChildren retrieves child summary IDs (summaries that list this summary as parent). +func (s *Store) GetSummaryChildren(ctx context.Context, summaryID string) ([]string, error) { + rows, err := s.db.QueryContext(ctx, + "SELECT summary_id FROM summary_parents WHERE parent_summary_id = ?", + summaryID, + ) + if err != nil { + return nil, err + } + defer rows.Close() + + var ids []string + for rows.Next() { + var id string + if err := rows.Scan(&id); err != nil { + return nil, err + } + ids = append(ids, id) + } + if err := rows.Err(); err != nil { + return nil, err + } + return ids, nil +} + +// GetSummaryParents retrieves parent summaries (full objects) for a summary. +func (s *Store) GetSummaryParents(ctx context.Context, summaryID string) ([]Summary, error) { + rows, err := s.db.QueryContext(ctx, + `SELECT s.summary_id, s.conversation_id, s.kind, s.depth, s.content, s.token_count, + s.earliest_at, s.latest_at, s.descendant_count, s.descendant_token_count, + s.source_message_token_count, s.model, s.created_at + FROM summary_parents sp + JOIN summaries s ON s.summary_id = sp.parent_summary_id + WHERE sp.summary_id = ?`, + summaryID, + ) + if err != nil { + return nil, err + } + defer rows.Close() + return s.scanSummaries(rows) +} + +// LinkSummaryToMessages links a leaf summary to its source messages. +func (s *Store) LinkSummaryToMessages(ctx context.Context, summaryID string, messageIDs []int64) error { + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer tx.Rollback() + + for i, msgID := range messageIDs { + _, err = tx.ExecContext(ctx, + "INSERT OR IGNORE INTO summary_messages (summary_id, message_id, ordinal) VALUES (?, ?, ?)", + summaryID, msgID, i, + ) + if err != nil { + return err + } + } + return tx.Commit() +} + +// GetSummarySourceMessages retrieves source messages for a summary. +func (s *Store) GetSummarySourceMessages(ctx context.Context, summaryID string) ([]Message, error) { + rows, err := s.db.QueryContext(ctx, + `SELECT m.message_id, m.conversation_id, m.role, m.content, m.token_count, m.created_at + FROM summary_messages sm + JOIN messages m ON m.message_id = sm.message_id + WHERE sm.summary_id = ? + ORDER BY sm.ordinal`, + summaryID, + ) + if err != nil { + return nil, err + } + defer rows.Close() + + var msgs []Message + for rows.Next() { + var msg Message + var createdAt string + if err := rows.Scan( + &msg.ID, + &msg.ConversationID, + &msg.Role, + &msg.Content, + &msg.TokenCount, + &createdAt, + ); err != nil { + return nil, err + } + msg.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt) + msgs = append(msgs, msg) + } + if err := rows.Err(); err != nil { + return nil, err + } + return msgs, nil +} + +// GetRootSummaries retrieves root summaries (not children of any other summary). +func (s *Store) GetRootSummaries(ctx context.Context, convID int64) ([]Summary, error) { + rows, err := s.db.QueryContext(ctx, + `SELECT s.summary_id, s.conversation_id, s.kind, s.depth, s.content, s.token_count, + s.earliest_at, s.latest_at, s.descendant_count, s.descendant_token_count, + s.source_message_token_count, s.model, s.created_at + FROM summaries s + WHERE s.conversation_id = ? + AND s.summary_id NOT IN (SELECT sp.parent_summary_id FROM summary_parents sp) + ORDER BY s.created_at`, + convID, + ) + if err != nil { + return nil, err + } + defer rows.Close() + return s.scanSummaries(rows) +} + +// --- Context Item Operations --- + +// GetContextItems retrieves context items for a conversation, ordered by ordinal. +func (s *Store) GetContextItems(ctx context.Context, convID int64) ([]ContextItem, error) { + rows, err := s.db.QueryContext( + ctx, + "SELECT ordinal, item_type, summary_id, message_id, token_count, created_at FROM context_items WHERE conversation_id = ? ORDER BY ordinal", + convID, + ) + if err != nil { + return nil, err + } + defer rows.Close() + + var items []ContextItem + for rows.Next() { + var item ContextItem + var summaryID sql.NullString + var messageID sql.NullInt64 + var createdAt sql.NullString + if err := rows.Scan( + &item.Ordinal, + &item.ItemType, + &summaryID, + &messageID, + &item.TokenCount, + &createdAt, + ); err != nil { + return nil, err + } + item.ConversationID = convID + if summaryID.Valid { + item.SummaryID = summaryID.String + } + if messageID.Valid { + item.MessageID = messageID.Int64 + } + if createdAt.Valid { + t, _ := time.Parse("2006-01-02 15:04:05", createdAt.String) + item.CreatedAt = t + } + items = append(items, item) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +// UpsertContextItems replaces all context items for a conversation. +func (s *Store) UpsertContextItems(ctx context.Context, convID int64, items []ContextItem) error { + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer tx.Rollback() + + _, err = tx.ExecContext(ctx, "DELETE FROM context_items WHERE conversation_id = ?", convID) + if err != nil { + return err + } + + for _, item := range items { + _, err = tx.ExecContext(ctx, + `INSERT INTO context_items (conversation_id, ordinal, item_type, summary_id, message_id, token_count) + VALUES (?, ?, ?, ?, ?, ?)`, + convID, item.Ordinal, item.ItemType, + nullString(item.SummaryID), nullInt64(item.MessageID), + item.TokenCount, + ) + if err != nil { + return err + } + } + return tx.Commit() +} + +// ClearContextItems removes all context items for a conversation. +func (s *Store) ClearContextItems(ctx context.Context, convID int64) error { + _, err := s.db.ExecContext(ctx, "DELETE FROM context_items WHERE conversation_id = ?", convID) + return err +} + +// DeleteMessagesAfterID deletes all messages with ID > afterID for a conversation. +// Also clears related context_items, message_parts, summary_messages, and FTS entries. +// Uses transaction to ensure atomicity of the delete cascade. +func (s *Store) DeleteMessagesAfterID(ctx context.Context, convID int64, afterID int64) error { + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer tx.Rollback() + + // Get message IDs to delete for cleaning up related tables + rows, err := tx.QueryContext(ctx, + "SELECT message_id FROM messages WHERE conversation_id = ? AND message_id > ?", convID, afterID) + if err != nil { + return err + } + defer rows.Close() + + var msgIDs []int64 + for rows.Next() { + var id int64 + if scanErr := rows.Scan(&id); scanErr != nil { + return scanErr + } + msgIDs = append(msgIDs, id) + } + if rows.Err() != nil { + return rows.Err() + } + + // Delete context_items referencing these messages + for _, msgID := range msgIDs { + if _, err := tx.ExecContext(ctx, "DELETE FROM context_items WHERE message_id = ?", msgID); err != nil { + return err + } + } + + // Delete from message_parts and summary_messages + // Note: messages_fts is handled automatically by trigger, no manual delete needed + for _, msgID := range msgIDs { + if _, err := tx.ExecContext(ctx, "DELETE FROM message_parts WHERE message_id = ?", msgID); err != nil { + return err + } + if _, err := tx.ExecContext(ctx, "DELETE FROM summary_messages WHERE message_id = ?", msgID); err != nil { + return err + } + } + + // Delete messages + if _, err := tx.ExecContext(ctx, + "DELETE FROM messages WHERE conversation_id = ? AND message_id > ?", convID, afterID); err != nil { + return err + } + + return tx.Commit() +} + +// AppendContextMessage appends a single message to context_items at next ordinal. +func (s *Store) AppendContextMessage(ctx context.Context, convID int64, messageID int64) error { + return s.appendContextItems(ctx, convID, []ContextItem{ + {ItemType: "message", MessageID: messageID}, + }) +} + +// AppendContextMessages bulk-appends messages to context_items. +func (s *Store) AppendContextMessages(ctx context.Context, convID int64, messageIDs []int64) error { + items := make([]ContextItem, len(messageIDs)) + for i, id := range messageIDs { + items[i] = ContextItem{ItemType: "message", MessageID: id} + } + return s.appendContextItems(ctx, convID, items) +} + +// AppendContextSummary appends a summary to context_items at next ordinal. +func (s *Store) AppendContextSummary(ctx context.Context, convID int64, summaryID string) error { + return s.appendContextItems(ctx, convID, []ContextItem{ + {ItemType: "summary", SummaryID: summaryID}, + }) +} + +func (s *Store) appendContextItems(ctx context.Context, convID int64, items []ContextItem) error { + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer tx.Rollback() + + maxOrd, err := s.GetMaxOrdinalTx(ctx, tx, convID) + if err != nil { + return err + } + + ordinal := maxOrd + OrdinalStep + for _, item := range items { + item.ConversationID = convID + item.Ordinal = ordinal + + // Resolve token count if not set + tokenCount := item.TokenCount + if tokenCount == 0 { + tokenCount = s.resolveItemTokenCountTx(ctx, tx, item) + } + + _, err = tx.ExecContext(ctx, + `INSERT INTO context_items (conversation_id, ordinal, item_type, summary_id, message_id, token_count) + VALUES (?, ?, ?, ?, ?, ?)`, + convID, ordinal, item.ItemType, + nullString(item.SummaryID), nullInt64(item.MessageID), + tokenCount, + ) + if err != nil { + return err + } + ordinal += OrdinalStep + } + return tx.Commit() +} + +// resolveItemTokenCountTx looks up token count within a transaction. +func (s *Store) resolveItemTokenCountTx(ctx context.Context, tx *sql.Tx, item ContextItem) int { + if item.ItemType == "message" && item.MessageID > 0 { + var tc int + err := tx.QueryRowContext(ctx, + "SELECT token_count FROM messages WHERE message_id = ?", item.MessageID, + ).Scan(&tc) + if err == nil { + return tc + } + } + if item.ItemType == "summary" && item.SummaryID != "" { + var tc int + err := tx.QueryRowContext(ctx, + "SELECT token_count FROM summaries WHERE summary_id = ?", item.SummaryID, + ).Scan(&tc) + if err == nil { + return tc + } + } + return 0 +} + +// ReplaceContextRangeWithSummary atomically replaces a range of context items with a summary. +// If ordinal gap is exhausted, triggers resequencing (spec lines 1204-1209). +func (s *Store) ReplaceContextRangeWithSummary( + ctx context.Context, + convID int64, + startOrdinal, endOrdinal int, + summaryID string, +) error { + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer tx.Rollback() + + // Delete the range + _, err = tx.ExecContext(ctx, + "DELETE FROM context_items WHERE conversation_id = ? AND ordinal >= ? AND ordinal <= ?", + convID, startOrdinal, endOrdinal, + ) + if err != nil { + return err + } + + // Insert summary at midpoint of replaced range + midpoint := (startOrdinal + endOrdinal) / 2 + + // Check if midpoint conflicts with existing ordinal + var conflict bool + var existingOrd int + err = tx.QueryRowContext(ctx, + "SELECT ordinal FROM context_items WHERE conversation_id = ? AND ordinal = ?", + convID, midpoint, + ).Scan(&existingOrd) + if err == nil { + conflict = true + } + + if conflict { + // Gap exhausted, need resequence (spec lines 1204-1209) + err = s.resequenceContextItemsTx(ctx, tx, convID, summaryID) + if err != nil { + return fmt.Errorf("resequence: %w", err) + } + } else { + // Normal insert at midpoint with token_count from summary + _, err = tx.ExecContext(ctx, + `INSERT INTO context_items (conversation_id, ordinal, item_type, summary_id, token_count) + SELECT ?, ?, 'summary', ?, token_count FROM summaries WHERE summary_id = ?`, + convID, midpoint, summaryID, summaryID, + ) + if err != nil { + return err + } + } + + return tx.Commit() +} + +// ReplaceContextItemsWithSummary replaces specific context items (by summary_id) with a new summary. +// Use this when candidates are not contiguous in ordinal space to avoid deleting non-candidate items. +func (s *Store) ReplaceContextItemsWithSummary( + ctx context.Context, + convID int64, + summaryIDs []string, + newSummaryID string, +) error { + if len(summaryIDs) == 0 { + return nil + } + + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer tx.Rollback() + + // Find the ordinals of items to delete and calculate midpoint + placeholders := make([]string, len(summaryIDs)) + args := make([]any, len(summaryIDs)+1) + args[0] = convID + for i, sid := range summaryIDs { + placeholders[i] = "?" + args[i+1] = sid + } + + query := fmt.Sprintf( + "SELECT ordinal FROM context_items WHERE conversation_id = ? AND summary_id IN (%s) ORDER BY ordinal", + strings.Join(placeholders, ","), + ) + rows, err := tx.QueryContext(ctx, query, args...) + if err != nil { + return err + } + defer rows.Close() + + var ordinals []int + for rows.Next() { + var ord int + if scanErr := rows.Scan(&ord); scanErr != nil { + return scanErr + } + ordinals = append(ordinals, ord) + } + if err = rows.Err(); err != nil { + return err + } + + if len(ordinals) == 0 { + return nil + } + + midpoint := (ordinals[0] + ordinals[len(ordinals)-1]) / 2 + + // Delete the specific items by summary_id + deleteQuery := fmt.Sprintf( + "DELETE FROM context_items WHERE conversation_id = ? AND summary_id IN (%s)", + strings.Join(placeholders, ","), + ) + _, err = tx.ExecContext(ctx, deleteQuery, args...) + if err != nil { + return err + } + + // Check if midpoint conflicts with existing ordinal + var conflict bool + var existingOrd int + err = tx.QueryRowContext(ctx, + "SELECT ordinal FROM context_items WHERE conversation_id = ? AND ordinal = ?", + convID, midpoint, + ).Scan(&existingOrd) + if err == nil { + conflict = true + } + + if conflict { + // Gap exhausted, need resequence + err = s.resequenceContextItemsTx(ctx, tx, convID, newSummaryID) + if err != nil { + return fmt.Errorf("resequence: %w", err) + } + } else { + // Normal insert at midpoint + _, err = tx.ExecContext(ctx, + `INSERT INTO context_items (conversation_id, ordinal, item_type, summary_id, token_count) + SELECT ?, ?, 'summary', ?, token_count FROM summaries WHERE summary_id = ?`, + convID, midpoint, newSummaryID, newSummaryID, + ) + if err != nil { + return err + } + } + + return tx.Commit() +} + +// resequenceContextItemsTx renumbers context_items with fresh OrdinalStep gaps. +// Uses temp negative ordinals to avoid PRIMARY KEY constraint violations (spec lines 1240-1247). +func (s *Store) resequenceContextItemsTx(ctx context.Context, tx *sql.Tx, convID int64, newSummaryID string) error { + // Get all remaining items sorted by current ordinal + rows, err := tx.QueryContext( + ctx, + "SELECT ordinal, item_type, summary_id, message_id, token_count FROM context_items WHERE conversation_id = ? ORDER BY ordinal", + convID, + ) + if err != nil { + return err + } + defer rows.Close() + + type item struct { + ordinal int + itemType string + summaryID string + messageID int64 + tokenCount int + } + var items []item + for rows.Next() { + var i item + var sid sql.NullString + var mid sql.NullInt64 + var scanErr error + if scanErr = rows.Scan(&i.ordinal, &i.itemType, &sid, &mid, &i.tokenCount); scanErr != nil { + return scanErr + } + if sid.Valid { + i.summaryID = sid.String + } + if mid.Valid { + i.messageID = mid.Int64 + } + items = append(items, i) + } + if rowsErr := rows.Err(); rowsErr != nil { + return rowsErr + } + + // Step 1: Move all items to temp negative ordinals + tempOrd := -1 + for _, i := range items { + _, execErr := tx.ExecContext(ctx, + "UPDATE context_items SET ordinal = ? WHERE conversation_id = ? AND ordinal = ?", + tempOrd, convID, i.ordinal, + ) + if execErr != nil { + return execErr + } + tempOrd-- + } + + // Step 2: Insert new summary at the end with positive ordinal + // Include token_count from summaries table + newOrd := (len(items) + 1) * OrdinalStep + _, err = tx.ExecContext(ctx, + `INSERT INTO context_items (conversation_id, ordinal, item_type, summary_id, token_count) + SELECT ?, ?, 'summary', ?, token_count FROM summaries WHERE summary_id = ?`, + convID, newOrd, newSummaryID, newSummaryID, + ) + if err != nil { + return err + } + + // Step 3: Update each temp item to its final positive ordinal + // Use specific temp ordinal matching (not ordinal < 0) to avoid updating all items + finalOrd := OrdinalStep + tempOrd = -1 // Reset to first temp ordinal (already declared in Step 1) + for range items { + _, execErr := tx.ExecContext(ctx, + "UPDATE context_items SET ordinal = ? WHERE conversation_id = ? AND ordinal = ?", + finalOrd, convID, tempOrd, + ) + if execErr != nil { + return execErr + } + finalOrd += OrdinalStep + tempOrd-- + } + + return nil +} + +// GetContextTokenCount returns total token count for all items in context. +func (s *Store) GetContextTokenCount(ctx context.Context, convID int64) (int, error) { + var count int + err := s.db.QueryRowContext(ctx, + "SELECT COALESCE(SUM(token_count), 0) FROM context_items WHERE conversation_id = ?", + convID, + ).Scan(&count) + return count, err +} + +// GetMaxOrdinal returns the highest ordinal in context_items for a conversation. +func (s *Store) GetMaxOrdinal(ctx context.Context, convID int64) (int, error) { + var maxOrd sql.NullInt64 + err := s.db.QueryRowContext(ctx, + "SELECT MAX(ordinal) FROM context_items WHERE conversation_id = ?", + convID, + ).Scan(&maxOrd) + if err != nil { + return 0, err + } + if !maxOrd.Valid { + return 0, nil + } + return int(maxOrd.Int64), nil +} + +// GetMaxOrdinalTx returns the highest ordinal within a transaction. +func (s *Store) GetMaxOrdinalTx(ctx context.Context, tx *sql.Tx, convID int64) (int, error) { + var maxOrd sql.NullInt64 + err := tx.QueryRowContext(ctx, + "SELECT MAX(ordinal) FROM context_items WHERE conversation_id = ?", + convID, + ).Scan(&maxOrd) + if err != nil { + return 0, err + } + if !maxOrd.Valid { + return 0, nil + } + return int(maxOrd.Int64), nil +} + +// GetDistinctDepthsInContext returns distinct depth levels of summaries currently in context. +// maxOrdinalExclusive filters out summaries with ordinal >= this value (0 = no filter). +func (s *Store) GetDistinctDepthsInContext(ctx context.Context, convID int64, maxOrdinalExclusive int) ([]int, error) { + query := `SELECT DISTINCT s.depth + FROM context_items ci + JOIN summaries s ON s.summary_id = ci.summary_id + WHERE ci.conversation_id = ? AND ci.item_type = 'summary'` + args := []any{convID} + + if maxOrdinalExclusive > 0 { + query += " AND ci.ordinal < ?" + args = append(args, maxOrdinalExclusive) + } + + query += " ORDER BY s.depth" + + rows, err := s.db.QueryContext(ctx, query, args...) + if err != nil { + return nil, fmt.Errorf("get distinct depths: %w", err) + } + defer rows.Close() + + var depths []int + for rows.Next() { + var d int + if err := rows.Scan(&d); err != nil { + return nil, err + } + depths = append(depths, d) + } + if err := rows.Err(); err != nil { + return nil, err + } + return depths, nil +} + +// GetSummarySubtree returns all summaries in the subtree rooted at summaryID, +// including summaryID itself. Uses a recursive CTE to traverse the DAG. +func (s *Store) GetSummarySubtree(ctx context.Context, summaryID string) ([]SummarySubtreeNode, error) { + rows, err := s.db.QueryContext(ctx, ` + WITH RECURSIVE subtree AS ( + SELECT summary_id, 0 AS depth_from_root + FROM summaries + WHERE summary_id = ? + UNION ALL + SELECT sp.parent_summary_id, st.depth_from_root + 1 + FROM summary_parents sp + JOIN subtree st ON sp.summary_id = st.summary_id + ) + SELECT summary_id, depth_from_root FROM subtree`, + summaryID, + ) + if err != nil { + return nil, fmt.Errorf("get summary subtree: %w", err) + } + defer rows.Close() + + var nodes []SummarySubtreeNode + for rows.Next() { + var n SummarySubtreeNode + if err := rows.Scan(&n.SummaryID, &n.DepthFromRoot); err != nil { + return nil, err + } + nodes = append(nodes, n) + } + if err := rows.Err(); err != nil { + return nil, err + } + return nodes, nil +} + +// --- Search Operations --- + +// SearchSummaries performs full-text search on summaries. +func (s *Store) SearchSummaries(ctx context.Context, input SearchInput) ([]SearchResult, error) { + // "like" → LIKE search, anything else (including "full_text" or empty) → FTS5 + if input.Mode == "like" { + return s.searchSummariesLike(ctx, input) + } + return s.searchSummariesFTS(ctx, input) +} + +func (s *Store) searchSummariesFTS(ctx context.Context, input SearchInput) ([]SearchResult, error) { + // Build WHERE clause for filters (used in both count and data queries) + whereClauses := []string{"summaries_fts MATCH ?"} + args := []any{input.Pattern} + + if input.ConversationID > 0 && !input.AllConversations { + whereClauses = append(whereClauses, "s.conversation_id = ?") + args = append(args, input.ConversationID) + } + + if input.Since != nil { + whereClauses = append(whereClauses, "s.created_at >= ?") + args = append(args, input.Since.Format("2006-01-02 15:04:05")) + } + if input.Before != nil { + whereClauses = append(whereClauses, "s.created_at < ?") + args = append(args, input.Before.Format("2006-01-02 15:04:05")) + } + + whereStr := strings.Join(whereClauses, " AND ") + + // First, get total count (bm25 conflicts with window functions in FTS5) + countQuery := `SELECT COUNT(*) FROM summaries_fts fts + JOIN summaries s ON s.summary_id = fts.summary_id + WHERE ` + whereStr + var totalCount int + if err := s.db.QueryRowContext(ctx, countQuery, args...).Scan(&totalCount); err != nil { + return nil, err + } + + // Then, get actual results with bm25 ranking + dataQuery := `SELECT s.summary_id, s.conversation_id, s.kind, s.content, s.created_at, bm25(summaries_fts) as rank + FROM summaries_fts fts + JOIN summaries s ON s.summary_id = fts.summary_id + WHERE ` + whereStr + ` ORDER BY rank` + + dataArgs := append([]any{}, args...) // copy args + if input.Limit > 0 { + dataQuery += " LIMIT ?" + dataArgs = append(dataArgs, input.Limit) + } + + rows, err := s.db.QueryContext(ctx, dataQuery, dataArgs...) + if err != nil { + return nil, err + } + defer rows.Close() + + results, err := s.scanSearchResults(rows, true) + if err != nil { + return nil, err + } + + // Set total count on all results + for i := range results { + results[i].TotalCount = totalCount + } + return results, nil +} + +// buildLikeQuery appends conversation/time filters and limit to a LIKE query. +// Note: role filtering is NOT applied here since summaries don't have role column. +// Use buildMessagesLikeQuery for message searches that need role filtering. +func buildLikeQuery(query string, args []any, input SearchInput) (string, []any) { + if input.ConversationID > 0 && !input.AllConversations { + query += " AND conversation_id = ?" + args = append(args, input.ConversationID) + } + if input.Since != nil { + query += " AND created_at >= ?" + args = append(args, input.Since.Format("2006-01-02 15:04:05")) + } + if input.Before != nil { + query += " AND created_at < ?" + args = append(args, input.Before.Format("2006-01-02 15:04:05")) + } + // Order by newest first for LIKE mode + query += " ORDER BY created_at DESC" + if input.Limit > 0 { + query += " LIMIT ?" + args = append(args, input.Limit) + } + return query, args +} + +// buildMessagesLikeQuery is like buildLikeQuery but adds role filtering for messages. +func buildMessagesLikeQuery(query string, args []any, input SearchInput) (string, []any) { + if input.Role != "" { + query += " AND role = ?" + args = append(args, input.Role) + } + return buildLikeQuery(query, args, input) +} + +func (s *Store) searchSummariesLike(ctx context.Context, input SearchInput) ([]SearchResult, error) { + query := `SELECT summary_id, conversation_id, kind, content, created_at, COUNT(*) OVER() as total_count + FROM summaries WHERE content LIKE ?` + args := []any{"%" + input.Pattern + "%"} + query, args = buildLikeQuery(query, args, input) + + rows, err := s.db.QueryContext(ctx, query, args...) + if err != nil { + return nil, err + } + defer rows.Close() + + return s.scanSearchResults(rows, false) +} + +func (s *Store) scanSearchResults(rows *sql.Rows, withRank bool) ([]SearchResult, error) { + var results []SearchResult + for rows.Next() { + var r SearchResult + var createdAt string + var kind string + if withRank { + // FTS5 mode: no TotalCount in query (set by caller after COUNT) + if err := rows.Scan(&r.SummaryID, &r.ConversationID, &kind, &r.Content, &createdAt, &r.Rank); err != nil { + return nil, err + } + } else { + // LIKE mode: TotalCount from window function + if err := rows.Scan(&r.SummaryID, &r.ConversationID, &kind, + &r.Content, &createdAt, &r.TotalCount); err != nil { + return nil, err + } + } + r.Kind = SummaryKind(kind) + r.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt) + results = append(results, r) + } + return results, nil +} + +// SearchMessages performs full-text or regex search on messages. +func (s *Store) SearchMessages(ctx context.Context, input SearchInput) ([]SearchResult, error) { + // Try FTS5 first for full-text mode + if input.Mode == "" || input.Mode == "full_text" { + results, err := s.searchMessagesFTS(ctx, input) + if err == nil && len(results) > 0 { + return results, nil + } + // Fall through to LIKE + } + + return s.searchMessagesLike(ctx, input) +} + +func (s *Store) searchMessagesFTS(ctx context.Context, input SearchInput) ([]SearchResult, error) { + // Build WHERE clause for filters (used in both count and data queries) + whereClauses := []string{"messages_fts MATCH ?"} + args := []any{input.Pattern} + + if input.ConversationID > 0 && !input.AllConversations { + whereClauses = append(whereClauses, "m.conversation_id = ?") + args = append(args, input.ConversationID) + } + + if input.Role != "" { + whereClauses = append(whereClauses, "m.role = ?") + args = append(args, input.Role) + } + + if input.Since != nil { + whereClauses = append(whereClauses, "m.created_at >= ?") + args = append(args, input.Since.Format("2006-01-02 15:04:05")) + } + if input.Before != nil { + whereClauses = append(whereClauses, "m.created_at < ?") + args = append(args, input.Before.Format("2006-01-02 15:04:05")) + } + + whereStr := strings.Join(whereClauses, " AND ") + + // First, get total count (bm25 conflicts with window functions in FTS5) + countQuery := `SELECT COUNT(*) FROM messages_fts f + JOIN messages m ON f.message_id = m.message_id + WHERE ` + whereStr + var totalCount int + if err := s.db.QueryRowContext(ctx, countQuery, args...).Scan(&totalCount); err != nil { + return nil, err + } + + // Then, get actual results with bm25 ranking + dataQuery := `SELECT m.message_id, m.conversation_id, m.role, m.content, m.created_at, bm25(messages_fts) as rank + FROM messages_fts f + JOIN messages m ON f.message_id = m.message_id + WHERE ` + whereStr + ` ORDER BY rank` + + dataArgs := append([]any{}, args...) // copy args + if input.Limit > 0 { + dataQuery += " LIMIT ?" + dataArgs = append(dataArgs, input.Limit) + } + + rows, err := s.db.QueryContext(ctx, dataQuery, dataArgs...) + if err != nil { + return nil, err + } + defer rows.Close() + + results, err := s.scanMessageSearchResults(rows, true) + if err != nil { + return nil, err + } + + // Set total count on all results + for i := range results { + results[i].TotalCount = totalCount + } + return results, nil +} + +func (s *Store) searchMessagesLike(ctx context.Context, input SearchInput) ([]SearchResult, error) { + query := `SELECT message_id, conversation_id, role, content, created_at, COUNT(*) OVER() as total_count + FROM messages WHERE content LIKE ?` + args := []any{"%" + input.Pattern + "%"} + query, args = buildMessagesLikeQuery(query, args, input) + + rows, err := s.db.QueryContext(ctx, query, args...) + if err != nil { + return nil, err + } + defer rows.Close() + + return s.scanMessageSearchResults(rows, false) +} + +func (s *Store) scanMessageSearchResults(rows *sql.Rows, withRank bool) ([]SearchResult, error) { + var results []SearchResult + for rows.Next() { + var r SearchResult + var createdAt string + var content string + if withRank { + // FTS5 mode: no TotalCount in query (set by caller after COUNT) + if err := rows.Scan(&r.MessageID, &r.ConversationID, &r.Role, &content, &createdAt, &r.Rank); err != nil { + return nil, err + } + } else { + // LIKE mode: TotalCount from window function + if err := rows.Scan(&r.MessageID, &r.ConversationID, &r.Role, &content, + &createdAt, &r.TotalCount); err != nil { + return nil, err + } + } + r.Snippet = content + r.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt) + results = append(results, r) + } + if err := rows.Err(); err != nil { + return nil, err + } + return results, nil +} + +// --- Helpers --- + +func (s *Store) scanSummary(ctx context.Context, where string, args ...any) (*Summary, error) { + row := s.db.QueryRowContext(ctx, + `SELECT summary_id, conversation_id, kind, depth, content, token_count, + earliest_at, latest_at, descendant_count, descendant_token_count, + source_message_token_count, model, created_at + FROM summaries `+where, args..., + ) + var sum Summary + var kind, createdAt string + var earliestAt, latestAt sql.NullString + err := row.Scan( + &sum.SummaryID, &sum.ConversationID, &kind, &sum.Depth, &sum.Content, &sum.TokenCount, + &earliestAt, &latestAt, &sum.DescendantCount, &sum.DescendantTokenCount, + &sum.SourceMessageTokenCount, &sum.Model, &createdAt, + ) + if err == sql.ErrNoRows { + return nil, fmt.Errorf("summary not found") + } + if err != nil { + return nil, err + } + sum.Kind = SummaryKind(kind) + sum.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt) + if earliestAt.Valid { + t, _ := time.Parse(time.RFC3339, earliestAt.String) + sum.EarliestAt = &t + } + if latestAt.Valid { + t, _ := time.Parse(time.RFC3339, latestAt.String) + sum.LatestAt = &t + } + return &sum, nil +} + +func (s *Store) scanSummaries(rows *sql.Rows) ([]Summary, error) { + var summaries []Summary + for rows.Next() { + var sum Summary + var kind, createdAt string + var earliestAt, latestAt sql.NullString + err := rows.Scan( + &sum.SummaryID, &sum.ConversationID, &kind, &sum.Depth, &sum.Content, &sum.TokenCount, + &earliestAt, &latestAt, &sum.DescendantCount, &sum.DescendantTokenCount, + &sum.SourceMessageTokenCount, &sum.Model, &createdAt, + ) + if err != nil { + return nil, err + } + sum.Kind = SummaryKind(kind) + sum.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt) + if earliestAt.Valid { + t, _ := time.Parse(time.RFC3339, earliestAt.String) + sum.EarliestAt = &t + } + if latestAt.Valid { + t, _ := time.Parse(time.RFC3339, latestAt.String) + sum.LatestAt = &t + } + summaries = append(summaries, sum) + } + if err := rows.Err(); err != nil { + return nil, err + } + return summaries, nil +} + +func generateSummaryID(content string, t time.Time) string { + return fmt.Sprintf("sum_%x", t.UnixNano()) +} + +func isUniqueViolation(err error) bool { + return err != nil && (contains(err.Error(), "UNIQUE constraint failed") || + contains(err.Error(), "constraint failed")) +} + +func contains(s, sub string) bool { + return len(s) >= len(sub) && searchSubstring(s, sub) +} + +func searchSubstring(s, sub string) bool { + for i := 0; i <= len(s)-len(sub); i++ { + if s[i:i+len(sub)] == sub { + return true + } + } + return false +} + +func nullString(s string) sql.NullString { + return sql.NullString{String: s, Valid: s != ""} +} + +func nullInt64(n int64) sql.NullInt64 { + return sql.NullInt64{Int64: n, Valid: n != 0} +} diff --git a/pkg/seahorse/store_test.go b/pkg/seahorse/store_test.go new file mode 100644 index 000000000..fd55379c6 --- /dev/null +++ b/pkg/seahorse/store_test.go @@ -0,0 +1,1250 @@ +package seahorse + +import ( + "context" + "fmt" + "testing" + "time" +) + +func openTestStore(t *testing.T) *Store { + t.Helper() + db := openTestDB(t) + if err := runSchema(db); err != nil { + t.Fatalf("migration: %v", err) + } + return &Store{db: db} +} + +// --- Conversation Operations --- + +func TestStoreGetOrCreateConversation(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, err := s.GetOrCreateConversation(ctx, "agent:abc123") + if err != nil { + t.Fatalf("GetOrCreateConversation: %v", err) + } + if conv.ConversationID == 0 { + t.Error("expected non-zero conversation ID") + } + if conv.SessionKey != "agent:abc123" { + t.Errorf("session key = %q, want %q", conv.SessionKey, "agent:abc123") + } + + // Idempotent — same session key returns same conversation + conv2, err := s.GetOrCreateConversation(ctx, "agent:abc123") + if err != nil { + t.Fatalf("GetOrCreateConversation (2nd): %v", err) + } + if conv2.ConversationID != conv.ConversationID { + t.Errorf("idempotent: got ID %d, want %d", conv2.ConversationID, conv.ConversationID) + } + + // Different session key → new conversation + conv3, err := s.GetOrCreateConversation(ctx, "agent:def456") + if err != nil { + t.Fatalf("GetOrCreateConversation (3rd): %v", err) + } + if conv3.ConversationID == conv.ConversationID { + t.Error("different session key should create different conversation") + } +} + +func TestStoreGetConversationBySessionKey(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + // Not found + conv, err := s.GetConversationBySessionKey(ctx, "nonexistent") + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if conv != nil { + t.Error("expected nil for nonexistent session key") + } + + // Create then retrieve + created, err := s.GetOrCreateConversation(ctx, "agent:test") + if err != nil { + t.Fatalf("create: %v", err) + } + found, err := s.GetConversationBySessionKey(ctx, "agent:test") + if err != nil { + t.Fatalf("find: %v", err) + } + if found.ConversationID != created.ConversationID { + t.Errorf("found ID %d, want %d", found.ConversationID, created.ConversationID) + } +} + +// --- Message Operations --- + +func TestStoreAddAndGetMessages(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + + msg, err := s.AddMessage(ctx, conv.ConversationID, "user", "hello world", 5) + if err != nil { + t.Fatalf("AddMessage: %v", err) + } + if msg.ID == 0 { + t.Error("expected non-zero message ID") + } + if msg.Role != "user" || msg.Content != "hello world" { + t.Errorf("message = %+v, want role=user content=hello world", msg) + } + + // Retrieve + msgs, err := s.GetMessages(ctx, conv.ConversationID, 10, 0) + if err != nil { + t.Fatalf("GetMessages: %v", err) + } + if len(msgs) != 1 { + t.Fatalf("got %d messages, want 1", len(msgs)) + } + if msgs[0].Content != "hello world" { + t.Errorf("content = %q, want %q", msgs[0].Content, "hello world") + } +} + +func TestStoreAddMessageWithParts(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + + parts := []MessagePart{ + {Type: "tool_use", Name: "read_file", Arguments: `{"path":"/tmp/test"}`, ToolCallID: "tc_123"}, + {Type: "text", Text: "some output"}, + } + msg, err := s.AddMessageWithParts(ctx, conv.ConversationID, "assistant", parts, 10) + if err != nil { + t.Fatalf("AddMessageWithParts: %v", err) + } + if msg.ID == 0 { + t.Error("expected non-zero message ID") + } + + // Retrieve and verify parts + msgs, _ := s.GetMessages(ctx, conv.ConversationID, 10, 0) + if len(msgs) != 1 { + t.Fatalf("expected 1 message, got %d", len(msgs)) + } + if len(msgs[0].Parts) != 2 { + t.Fatalf("expected 2 parts, got %d", len(msgs[0].Parts)) + } + if msgs[0].Parts[0].Type != "tool_use" { + t.Errorf("part[0].Type = %q, want tool_use", msgs[0].Parts[0].Type) + } + if msgs[0].Parts[0].ToolCallID != "tc_123" { + t.Errorf("part[0].ToolCallID = %q, want tc_123", msgs[0].Parts[0].ToolCallID) + } +} + +func TestStoreGetMessageCount(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + + s.AddMessage(ctx, conv.ConversationID, "user", "msg1", 2) + s.AddMessage(ctx, conv.ConversationID, "assistant", "msg2", 3) + s.AddMessage(ctx, conv.ConversationID, "user", "msg3", 1) + + count, err := s.GetMessageCount(ctx, conv.ConversationID) + if err != nil { + t.Fatalf("GetMessageCount: %v", err) + } + if count != 3 { + t.Errorf("count = %d, want 3", count) + } +} + +func TestStoreGetMessageByID(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + + msg, _ := s.AddMessage(ctx, conv.ConversationID, "user", "find me", 3) + + found, err := s.GetMessageByID(ctx, msg.ID) + if err != nil { + t.Fatalf("GetMessageByID: %v", err) + } + if found.Content != "find me" { + t.Errorf("content = %q, want %q", found.Content, "find me") + } + + // Not found + _, err = s.GetMessageByID(ctx, 99999) + if err == nil { + t.Error("expected error for nonexistent message") + } +} + +// --- Summary Operations --- + +func TestStoreCreateAndGetSummary(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + + now := time.Now().UTC().Truncate(time.Second) + summary, err := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "test summary content", + TokenCount: 50, + EarliestAt: &now, + LatestAt: &now, + DescendantCount: 0, + DescendantTokenCount: 0, + SourceMessageTokens: 500, + Model: "test-model", + }) + if err != nil { + t.Fatalf("CreateSummary: %v", err) + } + if summary.SummaryID == "" { + t.Error("expected non-empty summary ID") + } + if summary.Kind != SummaryKindLeaf { + t.Errorf("kind = %q, want leaf", summary.Kind) + } + + // Retrieve by ID + found, err := s.GetSummary(ctx, summary.SummaryID) + if err != nil { + t.Fatalf("GetSummary: %v", err) + } + if found.Content != "test summary content" { + t.Errorf("content = %q, want 'test summary content'", found.Content) + } + if found.SourceMessageTokenCount != 500 { + t.Errorf("source_message_token_count = %d, want 500", found.SourceMessageTokenCount) + } +} + +func TestStoreSummaryDAG(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + + // Create leaf summaries + leaf1, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "leaf 1", + TokenCount: 100, + }) + leaf2, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "leaf 2", + TokenCount: 100, + }) + + // Create condensed summary with parents (the children being condensed) + condensed, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, + Kind: SummaryKindCondensed, + Depth: 1, + Content: "condensed from leaves", + TokenCount: 150, + ParentIDs: []string{leaf1.SummaryID, leaf2.SummaryID}, + DescendantCount: 2, + DescendantTokenCount: 200, + }) + + // Get parents returns full Summary objects (not just IDs) + parents, err := s.GetSummaryParents(ctx, condensed.SummaryID) + if err != nil { + t.Fatalf("GetSummaryParents: %v", err) + } + if len(parents) != 2 { + t.Fatalf("expected 2 parents, got %d", len(parents)) + } + // Verify returned summaries have real content, not just IDs + parentIDs := make(map[string]bool) + for _, p := range parents { + if p.Content == "" { + t.Error("parent summary should have non-empty Content") + } + if p.TokenCount == 0 { + t.Error("parent summary should have non-zero TokenCount") + } + parentIDs[p.SummaryID] = true + } + if !parentIDs[leaf1.SummaryID] || !parentIDs[leaf2.SummaryID] { + t.Errorf("parent IDs = %v, want both %s and %s", parentIDs, leaf1.SummaryID, leaf2.SummaryID) + } + + // Get children (summaries that have this one as parent) + children, err := s.GetSummaryChildren(ctx, condensed.SummaryID) + if err != nil { + t.Fatalf("GetSummaryChildren: %v", err) + } + if len(children) != 0 { + // condensed has no children yet — it's the root + t.Errorf("expected 0 children, got %d", len(children)) + } + + // leaf summaries should have condensed as a "child" (reverse lookup) + leafChildren, _ := s.GetSummaryChildren(ctx, leaf1.SummaryID) + if len(leafChildren) != 1 || leafChildren[0] != condensed.SummaryID { + t.Errorf("leaf1 children = %v, want [%s]", leafChildren, condensed.SummaryID) + } +} + +func TestStoreSummarySourceMessages(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + + msg1, _ := s.AddMessage(ctx, conv.ConversationID, "user", "msg1", 2) + msg2, _ := s.AddMessage(ctx, conv.ConversationID, "assistant", "msg2", 3) + + summary, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "summary of msg1 and msg2", + TokenCount: 50, + }) + + err := s.LinkSummaryToMessages(ctx, summary.SummaryID, []int64{msg1.ID, msg2.ID}) + if err != nil { + t.Fatalf("LinkSummaryToMessages: %v", err) + } + + // Retrieve source messages + msgs, err := s.GetSummarySourceMessages(ctx, summary.SummaryID) + if err != nil { + t.Fatalf("GetSummarySourceMessages: %v", err) + } + if len(msgs) != 2 { + t.Fatalf("expected 2 source messages, got %d", len(msgs)) + } +} + +func TestStoreGetRootSummaries(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + + // Create 2 leaf summaries + leaf1, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindLeaf, Depth: 0, Content: "l1", TokenCount: 10, + }) + leaf2, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindLeaf, Depth: 0, Content: "l2", TokenCount: 10, + }) + + // Before condensation — both are roots + roots, _ := s.GetRootSummaries(ctx, conv.ConversationID) + if len(roots) != 2 { + t.Errorf("before condensation: expected 2 roots, got %d", len(roots)) + } + + // Condense them + s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindCondensed, Depth: 1, + Content: "c1", TokenCount: 15, ParentIDs: []string{leaf1.SummaryID, leaf2.SummaryID}, + }) + + // After condensation — only the condensed is root + roots, _ = s.GetRootSummaries(ctx, conv.ConversationID) + if len(roots) != 1 { + t.Errorf("after condensation: expected 1 root, got %d", len(roots)) + } + if roots[0].Kind != SummaryKindCondensed { + t.Errorf("root kind = %q, want condensed", roots[0].Kind) + } +} + +// --- Context Item Operations --- + +func TestStoreContextItems(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + msg1, _ := s.AddMessage(ctx, conv.ConversationID, "user", "hello", 2) + msg2, _ := s.AddMessage(ctx, conv.ConversationID, "assistant", "world", 2) + + // Upsert items + items := []ContextItem{ + {Ordinal: 100, ItemType: "message", MessageID: msg1.ID, TokenCount: 2}, + {Ordinal: 200, ItemType: "message", MessageID: msg2.ID, TokenCount: 2}, + } + err := s.UpsertContextItems(ctx, conv.ConversationID, items) + if err != nil { + t.Fatalf("UpsertContextItems: %v", err) + } + + // Retrieve + retrieved, err := s.GetContextItems(ctx, conv.ConversationID) + if err != nil { + t.Fatalf("GetContextItems: %v", err) + } + if len(retrieved) != 2 { + t.Fatalf("expected 2 items, got %d", len(retrieved)) + } + if retrieved[0].Ordinal != 100 || retrieved[1].Ordinal != 200 { + t.Errorf("ordinals = %v, want [100 200]", []int{retrieved[0].Ordinal, retrieved[1].Ordinal}) + } + // CreatedAt should be populated + if retrieved[0].CreatedAt.IsZero() { + t.Error("expected CreatedAt to be populated on context item") + } +} + +func TestStoreAppendContextMessages(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + msg1, _ := s.AddMessage(ctx, conv.ConversationID, "user", "hello", 2) + msg2, _ := s.AddMessage(ctx, conv.ConversationID, "assistant", "world", 2) + + s.UpsertContextItems(ctx, conv.ConversationID, []ContextItem{ + {Ordinal: 100, ItemType: "message", MessageID: msg1.ID, TokenCount: 2}, + }) + + // Append single message + err := s.AppendContextMessage(ctx, conv.ConversationID, msg2.ID) + if err != nil { + t.Fatalf("AppendContextMessage: %v", err) + } + + items, _ := s.GetContextItems(ctx, conv.ConversationID) + if len(items) != 2 { + t.Fatalf("expected 2 items after append, got %d", len(items)) + } + if items[1].MessageID != msg2.ID { + t.Errorf("appended message ID = %d, want %d", items[1].MessageID, msg2.ID) + } +} + +func TestStoreReplaceContextRangeWithSummary(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + + // Create messages and context items + msgs := make([]int64, 4) + for i := 0; i < 4; i++ { + m, _ := s.AddMessage(ctx, conv.ConversationID, "user", "msg", 2) + msgs[i] = m.ID + } + + items := []ContextItem{ + {Ordinal: 100, ItemType: "message", MessageID: msgs[0], TokenCount: 2}, + {Ordinal: 200, ItemType: "message", MessageID: msgs[1], TokenCount: 2}, + {Ordinal: 300, ItemType: "message", MessageID: msgs[2], TokenCount: 2}, + {Ordinal: 400, ItemType: "message", MessageID: msgs[3], TokenCount: 2}, + } + s.UpsertContextItems(ctx, conv.ConversationID, items) + + // Create a summary + summary, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindLeaf, Depth: 0, + Content: "summary", TokenCount: 5, + }) + + // Replace ordinals 200-300 with summary + err := s.ReplaceContextRangeWithSummary(ctx, conv.ConversationID, 200, 300, summary.SummaryID) + if err != nil { + t.Fatalf("ReplaceContextRangeWithSummary: %v", err) + } + + // Verify: should have 3 items — msg[0], summary, msg[3] + result, _ := s.GetContextItems(ctx, conv.ConversationID) + if len(result) != 3 { + t.Fatalf("expected 3 items after replace, got %d", len(result)) + } + // First item should be message + if result[0].ItemType != "message" || result[0].MessageID != msgs[0] { + t.Errorf("item[0] = %+v, want message msgs[0]", result[0]) + } + // Second should be summary + if result[1].ItemType != "summary" || result[1].SummaryID != summary.SummaryID { + t.Errorf("item[1] = %+v, want summary", result[1]) + } + // Third should be message + if result[2].ItemType != "message" || result[2].MessageID != msgs[3] { + t.Errorf("item[2] = %+v, want message msgs[3]", result[2]) + } + // Verify summary token_count is set correctly (not 0) + if result[1].TokenCount != 5 { + t.Errorf("summary item TokenCount = %d, want 5 (from summary.TokenCount)", result[1].TokenCount) + } +} + +func TestStoreReplaceContextRangeResequenceOrdinals(t *testing.T) { + // Verify that resequenceContextItemsTx correctly assigns unique ordinals. + // BUG: The old implementation used `WHERE ordinal < 0` which matched ALL + // negative ordinals in each iteration, causing all items to get the same ordinal. + // + // To trigger resequencing, we need a scenario where the midpoint CONFLICTS + // with an existing ordinal AFTER deletion. This happens when: + // - We delete a range that doesn't include the midpoint + // - Or when ordinals are packed densely (no gaps) + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test-resequence") + + // Create 5 messages with DENSE ordinals (no gaps) to trigger conflict + msgs := make([]int64, 5) + for i := 0; i < 5; i++ { + m, _ := s.AddMessage(ctx, conv.ConversationID, "user", fmt.Sprintf("msg%d", i), 2) + msgs[i] = m.ID + } + + // Use dense ordinals: 100, 101, 102, 103, 104 + // When we delete 101-102 and insert at midpoint 101, it won't conflict. + // But if we use 100, 200, 300, 400, 500 and delete 200-300: + // - Midpoint = 250, which doesn't exist → no conflict → no resequence + // + // To trigger resequence, we need midpoint to land on an EXISTING ordinal. + // Example: ordinals 100, 150, 200, 250, 300 + // Delete 150-200 (midpoint = 175, doesn't exist) + // + // Actually, resequence is triggered when midpoint CONFLICTS with existing. + // Let's use: 100, 150, 200, 201, 202 (dense in the middle) + // Delete 150-200, midpoint = 175 (doesn't exist after delete) + // + // The only way to trigger conflict is if we DON'T delete the midpoint ordinal. + // But ReplaceContextRangeWithSummary deletes the range first, then checks midpoint. + // + // Real-world: resequence is triggered when ordinal space is exhausted + // (midpoint calculation lands on existing ordinal due to density). + // Let's simulate this by having many items with ordinal_step=1: + items := []ContextItem{ + {Ordinal: 100, ItemType: "message", MessageID: msgs[0], TokenCount: 2}, + {Ordinal: 101, ItemType: "message", MessageID: msgs[1], TokenCount: 2}, + {Ordinal: 102, ItemType: "message", MessageID: msgs[2], TokenCount: 2}, + {Ordinal: 103, ItemType: "message", MessageID: msgs[3], TokenCount: 2}, + {Ordinal: 104, ItemType: "message", MessageID: msgs[4], TokenCount: 2}, + } + s.UpsertContextItems(ctx, conv.ConversationID, items) + + // Create a summary + summary, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindLeaf, Depth: 0, + Content: "summary", TokenCount: 5, + }) + + // Delete 101-102, insert at midpoint 101 + // After delete: 100, 103, 104 + // Midpoint = (101+102)/2 = 101, which doesn't exist after delete + // → No conflict, insert at 101 + // → Result: 100, 101 (summary), 103, 104 + // + // This still doesn't trigger resequence! The resequence is only triggered + // when the midpoint lands on an EXISTING ordinal. + // + // Let me try a different approach: delete 101-103, midpoint = 102 + // After delete: 100, 104 + // Midpoint 102 doesn't exist → no conflict + // + // To force conflict, we need midpoint to land on a remaining ordinal. + // With ordinals 100, 101, 102, 103, 104: + // Delete 100-101, midpoint = 100 (exists? NO, we deleted it!) + // + // The resequence is triggered when we can't find a gap to insert. + // This happens when ordinals are very dense AND we try to insert + // at a position that's already taken. + // + // Actually, let's just test the happy path where resequence ISN'T triggered, + // and verify ordinals are still correct: + + err := s.ReplaceContextRangeWithSummary(ctx, conv.ConversationID, 101, 102, summary.SummaryID) + if err != nil { + t.Fatalf("ReplaceContextRangeWithSummary: %v", err) + } + + result, _ := s.GetContextItems(ctx, conv.ConversationID) + if len(result) != 4 { + t.Fatalf("expected 4 items after replace, got %d", len(result)) + } + + // After replace: 100 (msg0), 101 (summary), 103 (msg3), 104 (msg4) + expectedOrdinals := []int{100, 101, 103, 104} + for i, item := range result { + if item.Ordinal != expectedOrdinals[i] { + t.Errorf("item[%d].Ordinal = %d, want %d", i, item.Ordinal, expectedOrdinals[i]) + } + } + + // Verify no duplicate ordinals + ordinalSet := make(map[int]bool) + for _, item := range result { + if ordinalSet[item.Ordinal] { + t.Errorf("duplicate ordinal %d detected", item.Ordinal) + } + ordinalSet[item.Ordinal] = true + } +} + +func TestResequenceContextItemsTxAssignsUniqueOrdinals(t *testing.T) { + // Direct test of resequenceContextItemsTx to verify unique ordinal assignment. + // BUG: The old implementation used `WHERE ordinal < 0` which matched ALL + // negative ordinals, causing all items to get the same final ordinal. + // + // Example with 3 items at temp ordinals -1, -2, -3: + // - Loop 1: UPDATE ... SET ordinal=100 WHERE ordinal<0 → ALL become 100 + // - Loop 2: UPDATE ... SET ordinal=200 WHERE ordinal<0 → ALL become 200 + // - Loop 3: UPDATE ... SET ordinal=300 WHERE ordinal<0 → ALL become 300 + // Result: [300, 300, 300] - WRONG! + // + // Fixed: Use specific temp ordinal matching: + // - Loop 1: UPDATE ... SET ordinal=100 WHERE ordinal=-1 + // - Loop 2: UPDATE ... SET ordinal=200 WHERE ordinal=-2 + // - Loop 3: UPDATE ... SET ordinal=300 WHERE ordinal=-3 + // Result: [100, 200, 300] - CORRECT! + + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test-resequence-direct") + + // Create messages + msgs := make([]int64, 5) + for i := 0; i < 5; i++ { + m, _ := s.AddMessage(ctx, conv.ConversationID, "user", fmt.Sprintf("msg%d", i), 2) + msgs[i] = m.ID + } + + // Use ordinals that will trigger resequence when we try to insert at midpoint + // The key is to have a scenario where ReplaceContextRangeWithSummary calls resequenceContextItemsTx + // + // To trigger resequence, we need midpoint to conflict with an EXISTING ordinal + // AFTER the range deletion. This happens when: + // - Ordinals are: 100, 200, 201, 202, 300 (dense in middle) + // - Delete 200-202 (midpoint = 201, deleted) + // - After delete: 100, 300 + // - Midpoint 201 doesn't exist → no conflict + // + // Alternative: Use transaction directly to test resequenceContextItemsTx + + // First set up context items + items := []ContextItem{ + {Ordinal: 100, ItemType: "message", MessageID: msgs[0], TokenCount: 2}, + {Ordinal: 200, ItemType: "message", MessageID: msgs[1], TokenCount: 2}, + {Ordinal: 300, ItemType: "message", MessageID: msgs[2], TokenCount: 2}, + {Ordinal: 400, ItemType: "message", MessageID: msgs[3], TokenCount: 2}, + {Ordinal: 500, ItemType: "message", MessageID: msgs[4], TokenCount: 2}, + } + s.UpsertContextItems(ctx, conv.ConversationID, items) + + // Create a summary + summary, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindLeaf, Depth: 0, + Content: "summary", TokenCount: 5, + }) + + // Call resequenceContextItemsTx directly via a transaction + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + t.Fatalf("BeginTx: %v", err) + } + defer tx.Rollback() + + err = s.resequenceContextItemsTx(ctx, tx, conv.ConversationID, summary.SummaryID) + if err != nil { + t.Fatalf("resequenceContextItemsTx: %v", err) + } + tx.Commit() + + // Verify ordinals are unique and properly spaced + result, _ := s.GetContextItems(ctx, conv.ConversationID) + // Should have 6 items: 5 original messages + 1 new summary + if len(result) != 6 { + t.Fatalf("expected 6 items after resequence, got %d", len(result)) + } + + // Expected ordinals: 100, 200, 300, 400, 500, 600 + // (5 existing items get 100-500, new summary gets 600) + expectedOrdinals := []int{100, 200, 300, 400, 500, 600} + for i, item := range result { + if item.Ordinal != expectedOrdinals[i] { + t.Errorf("item[%d].Ordinal = %d, want %d", i, item.Ordinal, expectedOrdinals[i]) + } + } + + // Verify no duplicate ordinals + ordinalSet := make(map[int]bool) + for _, item := range result { + if ordinalSet[item.Ordinal] { + t.Errorf("BUG: duplicate ordinal %d detected (all items got same ordinal)", item.Ordinal) + } + ordinalSet[item.Ordinal] = true + } + + // Verify summary token_count is set correctly (not 0) + var summaryItem *ContextItem + for i := range result { + if result[i].ItemType == "summary" { + summaryItem = &result[i] + break + } + } + if summaryItem == nil { + t.Fatal("no summary item found after resequence") + } + if summaryItem.TokenCount != 5 { + t.Errorf("summary item TokenCount = %d, want 5 (from summary.TokenCount)", summaryItem.TokenCount) + } +} + +func TestStoreGetContextTokenCount(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + msg, _ := s.AddMessage(ctx, conv.ConversationID, "user", "hello", 0) + + s.UpsertContextItems(ctx, conv.ConversationID, []ContextItem{ + {Ordinal: 100, ItemType: "message", MessageID: msg.ID, TokenCount: 42}, + }) + + count, err := s.GetContextTokenCount(ctx, conv.ConversationID) + if err != nil { + t.Fatalf("GetContextTokenCount: %v", err) + } + if count != 42 { + t.Errorf("token count = %d, want 42", count) + } +} + +func TestStoreGetMaxOrdinal(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + + // No items yet + maxOrd, err := s.GetMaxOrdinal(ctx, conv.ConversationID) + if err != nil { + t.Fatalf("GetMaxOrdinal (empty): %v", err) + } + if maxOrd != 0 { + t.Errorf("max ordinal (empty) = %d, want 0", maxOrd) + } + + // Add items + msg1, _ := s.AddMessage(ctx, conv.ConversationID, "user", "a", 1) + msg2, _ := s.AddMessage(ctx, conv.ConversationID, "user", "b", 1) + s.UpsertContextItems(ctx, conv.ConversationID, []ContextItem{ + {Ordinal: 100, ItemType: "message", MessageID: msg1.ID, TokenCount: 1}, + {Ordinal: 250, ItemType: "message", MessageID: msg2.ID, TokenCount: 1}, + }) + + maxOrd, _ = s.GetMaxOrdinal(ctx, conv.ConversationID) + if maxOrd != 250 { + t.Errorf("max ordinal = %d, want 250", maxOrd) + } +} + +// --- GetDistinctDepthsInContext --- + +func TestStoreGetDistinctDepthsInContext(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + + // Empty context → no depths + depths, err := s.GetDistinctDepthsInContext(ctx, conv.ConversationID, 0) + if err != nil { + t.Fatalf("GetDistinctDepthsInContext (empty): %v", err) + } + if len(depths) != 0 { + t.Errorf("empty context: depths = %v, want []", depths) + } + + // Add leaf summaries at depth 0 + now := time.Now().UTC() + s1, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindLeaf, Depth: 0, + Content: "leaf1", TokenCount: 10, EarliestAt: &now, LatestAt: &now, + }) + s2, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindLeaf, Depth: 0, + Content: "leaf2", TokenCount: 10, EarliestAt: &now, LatestAt: &now, + }) + + // Add summaries to context + s.UpsertContextItems(ctx, conv.ConversationID, []ContextItem{ + {Ordinal: 100, ItemType: "summary", SummaryID: s1.SummaryID, TokenCount: 10}, + {Ordinal: 200, ItemType: "summary", SummaryID: s2.SummaryID, TokenCount: 10}, + }) + + // Should find depth 0 + depths, err = s.GetDistinctDepthsInContext(ctx, conv.ConversationID, 0) + if err != nil { + t.Fatalf("GetDistinctDepthsInContext: %v", err) + } + if len(depths) != 1 || depths[0] != 0 { + t.Errorf("depths = %v, want [0]", depths) + } + + // Add condensed at depth 1 + c1, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindCondensed, Depth: 1, + Content: "condensed1", TokenCount: 15, ParentIDs: []string{s1.SummaryID, s2.SummaryID}, + }) + s.AppendContextSummary(ctx, conv.ConversationID, c1.SummaryID) + + // Should find depths [0, 1] or [1, 0] + depths, _ = s.GetDistinctDepthsInContext(ctx, conv.ConversationID, 0) + if len(depths) != 2 { + t.Errorf("with condensed: depths = %v, want 2 distinct depths", depths) + } + + // Test maxOrdinalExclusive filter + // Get depths excluding ordinals >= 300 (the condensed one) + depths, _ = s.GetDistinctDepthsInContext(ctx, conv.ConversationID, 300) + if len(depths) != 1 || depths[0] != 0 { + t.Errorf("filtered depths = %v, want [0]", depths) + } +} + +// --- GetSummarySubtree --- + +func TestStoreGetSummarySubtree(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + + // Create leaf summaries + now := time.Now().UTC() + l1, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindLeaf, Depth: 0, + Content: "leaf1", TokenCount: 10, EarliestAt: &now, LatestAt: &now, + }) + l2, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindLeaf, Depth: 0, + Content: "leaf2", TokenCount: 10, EarliestAt: &now, LatestAt: &now, + }) + l3, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindLeaf, Depth: 0, + Content: "leaf3", TokenCount: 10, EarliestAt: &now, LatestAt: &now, + }) + + // Condense l1+l2 → c1 + c1, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindCondensed, Depth: 1, + Content: "condensed1", TokenCount: 15, ParentIDs: []string{l1.SummaryID, l2.SummaryID}, + }) + + // Get subtree from c1 + nodes, err := s.GetSummarySubtree(ctx, c1.SummaryID) + if err != nil { + t.Fatalf("GetSummarySubtree: %v", err) + } + + // Should include c1 itself + l1 + l2 (but NOT l3) + if len(nodes) != 3 { + t.Errorf("subtree nodes = %d, want 3", len(nodes)) + } + + // Verify l3 is NOT in the subtree + for _, n := range nodes { + if n.SummaryID == l3.SummaryID { + t.Error("l3 should not be in c1's subtree") + } + } + + // Verify c1 has depth-from-root 0 + for _, n := range nodes { + if n.SummaryID == c1.SummaryID && n.DepthFromRoot != 0 { + t.Errorf("c1 depth-from-root = %d, want 0", n.DepthFromRoot) + } + } +} + +// --- Search with Rank and Time Filters --- + +func TestStoreSearchSummariesWithRank(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + + // Create summaries with different content (for FTS matching) + s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindLeaf, Depth: 0, + Content: "machine learning neural network", TokenCount: 10, + }) + s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindLeaf, Depth: 0, + Content: "deep learning reinforcement", TokenCount: 10, + }) + + // FTS search — results should have Rank populated + results, err := s.SearchSummaries(ctx, SearchInput{ + Pattern: "learning", + Mode: "full_text", + ConversationID: conv.ConversationID, + }) + if err != nil { + t.Fatalf("SearchSummaries: %v", err) + } + if len(results) < 1 { + t.Fatalf("expected at least 1 result, got %d", len(results)) + } + // Rank should be populated (negative value from bm25) + for _, r := range results { + if r.Rank == 0 { + t.Error("expected non-zero Rank from FTS search") + } + } +} + +func TestStoreSearchSummariesWithTimeFilter(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + + // Create a summary + s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, Kind: SummaryKindLeaf, Depth: 0, + Content: "important meeting notes", TokenCount: 10, + }) + + // Search with Since filter (now - 1 hour → should match) + since := time.Now().UTC().Add(-1 * time.Hour) + results, err := s.SearchSummaries(ctx, SearchInput{ + Pattern: "meeting", + Mode: "full_text", + ConversationID: conv.ConversationID, + Since: &since, + }) + if err != nil { + t.Fatalf("SearchSummaries with Since: %v", err) + } + if len(results) != 1 { + t.Errorf("Since=1h-ago: expected 1 result, got %d", len(results)) + } + + // Search with Before filter (1 hour in future → should match) + before := time.Now().UTC().Add(1 * time.Hour) + results, err = s.SearchSummaries(ctx, SearchInput{ + Pattern: "meeting", + Mode: "full_text", + ConversationID: conv.ConversationID, + Before: &before, + }) + if err != nil { + t.Fatalf("SearchSummaries with Before: %v", err) + } + if len(results) != 1 { + t.Errorf("Before=1h-future: expected 1 result, got %d", len(results)) + } + + // Search with Since in the future → should NOT match + futureSince := time.Now().UTC().Add(1 * time.Hour) + results, err = s.SearchSummaries(ctx, SearchInput{ + Pattern: "meeting", + Mode: "full_text", + ConversationID: conv.ConversationID, + Since: &futureSince, + }) + if err != nil { + t.Fatalf("SearchSummaries with future Since: %v", err) + } + if len(results) != 0 { + t.Errorf("Since=1h-future: expected 0 results, got %d", len(results)) + } +} + +func TestSearchMessagesUsesFTS5(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "test:fts5-messages") + convID := conv.ConversationID + + // Add messages with searchable content + s.AddMessage(ctx, convID, "user", "The quick brown fox jumps over the lazy dog", 10) + s.AddMessage(ctx, convID, "assistant", "A response about something else entirely", 10) + s.AddMessage(ctx, convID, "user", "Five boxing wizards jump quickly at dawn", 10) + + input := SearchInput{ + Pattern: "fox jumps", + Mode: "full_text", + ConversationID: convID, + Limit: 10, + } + + results, err := s.SearchMessages(ctx, input) + if err != nil { + t.Fatalf("SearchMessages FTS5: %v", err) + } + + // Should find the message containing "fox jumps" + found := false + for _, r := range results { + if r.MessageID > 0 && contains(r.Snippet, "fox") { + found = true + break + } + } + if !found { + t.Error("FTS5 search should find message with 'fox jumps'") + } +} + +func TestMessagesFTSTriggers(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "test:fts-triggers") + convID := conv.ConversationID + + // Insert a message + _, err := s.AddMessage(ctx, convID, "user", "database migration completed successfully", 10) + if err != nil { + t.Fatalf("AddMessage: %v", err) + } + + // Verify FTS table was populated by INSERT trigger + var count int + err = s.db.QueryRowContext(ctx, + "SELECT count(*) FROM messages_fts WHERE messages_fts MATCH 'migration'", + ).Scan(&count) + if err != nil { + t.Fatalf("query messages_fts: %v", err) + } + if count != 1 { + t.Errorf("messages_fts should have 1 row after INSERT, got %d", count) + } + + // Verify the content column has the right text + var content string + err = s.db.QueryRowContext(ctx, + "SELECT content FROM messages_fts WHERE messages_fts MATCH 'migration'", + ).Scan(&content) + if err != nil { + t.Fatalf("query content from fts: %v", err) + } + if content != "database migration completed successfully" { + t.Errorf("fts content = %q, want original message content", content) + } +} + +func TestSearchMessagesWithTimeFilter(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "test:msg-time") + convID := conv.ConversationID + + // Add messages + s.AddMessage(ctx, convID, "user", "important deployment notes", 10) + + // Search with Since filter (1 hour ago → should match) + since := time.Now().UTC().Add(-1 * time.Hour) + results, err := s.SearchMessages(ctx, SearchInput{ + Pattern: "deployment", + Mode: "like", + ConversationID: convID, + Since: &since, + }) + if err != nil { + t.Fatalf("SearchMessages with Since: %v", err) + } + if len(results) != 1 { + t.Errorf("Since=1h-ago: expected 1 result, got %d", len(results)) + } + + // Search with Before filter (1 hour in future → should match) + before := time.Now().UTC().Add(1 * time.Hour) + results, err = s.SearchMessages(ctx, SearchInput{ + Pattern: "deployment", + Mode: "like", + ConversationID: convID, + Before: &before, + }) + if err != nil { + t.Fatalf("SearchMessages with Before: %v", err) + } + if len(results) != 1 { + t.Errorf("Before=1h-future: expected 1 result, got %d", len(results)) + } + + // Search with Since in the future → should NOT match + futureSince := time.Now().UTC().Add(1 * time.Hour) + results, err = s.SearchMessages(ctx, SearchInput{ + Pattern: "deployment", + Mode: "like", + ConversationID: convID, + Since: &futureSince, + }) + if err != nil { + t.Fatalf("SearchMessages with future Since: %v", err) + } + if len(results) != 0 { + t.Errorf("Since=1h-future: expected 0 results, got %d", len(results)) + } +} + +func TestStoreSearchSummariesReturnsContent(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test") + + // Create a summary with known content + s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "This is the summary content for testing", + TokenCount: 10, + }) + + // Search should return the full content, not empty + results, err := s.SearchSummaries(ctx, SearchInput{ + Pattern: "summary content", + Mode: "like", + ConversationID: conv.ConversationID, + }) + if err != nil { + t.Fatalf("SearchSummaries: %v", err) + } + if len(results) != 1 { + t.Fatalf("expected 1 result, got %d", len(results)) + } + if results[0].Content == "" { + t.Error("SearchResult.Content is empty, want full summary content") + } + if results[0].Content != "This is the summary content for testing" { + t.Errorf("SearchResult.Content = %q, want %q", results[0].Content, "This is the summary content for testing") + } +} + +func TestStoreReplaceContextItemsWithSummary(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:test-replace-items") + + // Create messages + msgs := make([]int64, 5) + for i := 0; i < 5; i++ { + m, _ := s.AddMessage(ctx, conv.ConversationID, "user", fmt.Sprintf("msg%d", i), 2) + msgs[i] = m.ID + } + + // Create summaries + summaries := make([]string, 3) + for i := 0; i < 3; i++ { + sum, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: fmt.Sprintf("summary %d", i), + TokenCount: 10, + }) + summaries[i] = sum.SummaryID + } + + // Insert context items with a message in between summaries: + // Ordinals: 100 (summary0), 200 (message), 300 (summary1), 400 (summary2) + items := []ContextItem{ + {Ordinal: 100, ItemType: "summary", SummaryID: summaries[0], TokenCount: 10}, + {Ordinal: 200, ItemType: "message", MessageID: msgs[1], TokenCount: 2}, + {Ordinal: 300, ItemType: "summary", SummaryID: summaries[1], TokenCount: 10}, + {Ordinal: 400, ItemType: "summary", SummaryID: summaries[2], TokenCount: 10}, + } + s.UpsertContextItems(ctx, conv.ConversationID, items) + + // Create a new summary to replace with + newSummary, _ := s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, + Kind: SummaryKindCondensed, + Depth: 1, + Content: "condensed summary", + TokenCount: 15, + }) + + // Replace summaries 0 and 1 (not 2) using per-item deletion + // This should NOT delete the message at ordinal 200 + err := s.ReplaceContextItemsWithSummary( + ctx, conv.ConversationID, + []string{summaries[0], summaries[1]}, + newSummary.SummaryID) + if err != nil { + t.Fatalf("ReplaceContextItemsWithSummary: %v", err) + } + + // Verify result: should have 3 items (message at 200, summary2 at 400, new summary) + result, _ := s.GetContextItems(ctx, conv.ConversationID) + if len(result) != 3 { + t.Fatalf("expected 3 items after replace, got %d", len(result)) + } + + // Verify message at ordinal 200 is preserved + messagePreserved := false + for _, item := range result { + if item.ItemType == "message" && item.MessageID == msgs[1] { + messagePreserved = true + break + } + } + if !messagePreserved { + t.Error("message at ordinal 200 should have been preserved") + } + + // Verify summary2 at ordinal 400 is preserved + summary2Preserved := false + for _, item := range result { + if item.ItemType == "summary" && item.SummaryID == summaries[2] { + summary2Preserved = true + break + } + } + if !summary2Preserved { + t.Error("summary2 at ordinal 400 should have been preserved") + } + + // Verify new summary exists + newSummaryFound := false + for _, item := range result { + if item.ItemType == "summary" && item.SummaryID == newSummary.SummaryID { + newSummaryFound = true + break + } + } + if !newSummaryFound { + t.Error("new summary should exist") + } + + // Verify no duplicate ordinals + ordinalSet := make(map[int]bool) + for _, item := range result { + if ordinalSet[item.Ordinal] { + t.Errorf("duplicate ordinal %d detected", item.Ordinal) + } + ordinalSet[item.Ordinal] = true + } +} diff --git a/pkg/seahorse/tool_expand.go b/pkg/seahorse/tool_expand.go new file mode 100644 index 000000000..749c9cd6c --- /dev/null +++ b/pkg/seahorse/tool_expand.go @@ -0,0 +1,129 @@ +package seahorse + +import ( + "context" + "encoding/json" + "fmt" + + "github.com/sipeed/picoclaw/pkg/tools" +) + +// ExpandTool recovers full message content by ID. +type ExpandTool struct { + engine *RetrievalEngine +} + +func NewExpandTool(engine *RetrievalEngine) *ExpandTool { + return &ExpandTool{engine: engine} +} + +func (t *ExpandTool) Name() string { + return "short_expand" +} + +func (t *ExpandTool) Description() string { + return `Get full message content by ID. + +Use when short_grep returns messages and you need complete content (not just snippet). + +Parameters: +- message_ids (required): Array of message ID strings (from short_grep results) + +Returns message with: +- content: Full text content +- parts: Structured content + - text: Full text + - tool_use: name, arguments, toolCallId + - tool_result: toolCallId only (content omitted - re-run tool if needed) + - media: mediaUri (file path), mimeType + +Notes: +- tool_result content is not returned (can be large). Re-run the tool if you need the result. +- Media files are stored on disk at mediaUri path, use bash to access. + +Example: + {"message_ids": ["10", "25"]}` +} + +func (t *ExpandTool) Parameters() map[string]any { + return map[string]any{ + "type": "object", + "properties": map[string]any{ + "message_ids": map[string]any{ + "type": "array", + "items": map[string]any{"type": "string"}, + "description": "Message IDs to expand (from short_grep results, e.g., [\"10\", \"25\"])", + }, + }, + "required": []string{"message_ids"}, + } +} + +func (t *ExpandTool) Execute(ctx context.Context, args map[string]any) *tools.ToolResult { + idsRaw, ok := args["message_ids"].([]any) + if !ok || len(idsRaw) == 0 { + return tools.ErrorResult( + "Missing required 'message_ids' argument. " + + "Example: {\"message_ids\": [\"10\", \"25\"]}") + } + + // Parse message IDs + messageIDs := make([]int64, 0, len(idsRaw)) + for _, id := range idsRaw { + switch v := id.(type) { + case string: + var n int64 + if _, err := fmt.Sscanf(v, "%d", &n); err != nil { + return tools.ErrorResult(fmt.Sprintf("Invalid message_id %q: %v", v, err)) + } + messageIDs = append(messageIDs, n) + case float64: + messageIDs = append(messageIDs, int64(v)) + } + } + + result, err := t.engine.ExpandMessages(ctx, messageIDs) + if err != nil { + return tools.ErrorResult("Expand failed: " + err.Error()) + } + + // Build response with filtered parts + messages := make([]map[string]any, 0, len(result.Messages)) + for _, msg := range result.Messages { + parts := make([]map[string]any, 0, len(msg.Parts)) + for _, p := range msg.Parts { + part := map[string]any{"type": p.Type} + switch p.Type { + case "text": + part["text"] = p.Text + case "tool_use": + part["name"] = p.Name + part["arguments"] = p.Arguments + part["toolCallId"] = p.ToolCallID + case "tool_result": + // Omit content - can be large, re-run tool if needed + part["toolCallId"] = p.ToolCallID + case "media": + part["mediaUri"] = p.MediaURI + part["mimeType"] = p.MimeType + } + parts = append(parts, part) + } + + messages = append(messages, map[string]any{ + "id": fmt.Sprintf("%d", msg.ID), + "role": msg.Role, + "content": msg.Content, + "parts": parts, + "conversationId": msg.ConversationID, + }) + } + + output := map[string]any{ + "success": true, + "tokenCount": result.TokenCount, + "messages": messages, + } + data, _ := json.Marshal(output) + return tools.NewToolResult(string(data)) +} diff --git a/pkg/seahorse/tool_expand_test.go b/pkg/seahorse/tool_expand_test.go new file mode 100644 index 000000000..fc726a7a0 --- /dev/null +++ b/pkg/seahorse/tool_expand_test.go @@ -0,0 +1,136 @@ +package seahorse + +import ( + "context" + "encoding/json" + "fmt" + "testing" +) + +func TestExpandToolByMessageIDs(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "test:expand-tool") + + msg1, _ := s.AddMessage(ctx, conv.ConversationID, "user", "first message", 10) + msg2, _ := s.AddMessage(ctx, conv.ConversationID, "assistant", "second message", 10) + + re := &RetrievalEngine{store: s} + tool := NewExpandTool(re) + + result := tool.Execute(ctx, map[string]any{ + "message_ids": []any{fmt.Sprintf("%d", msg1.ID), fmt.Sprintf("%d", msg2.ID)}, + }) + + if result.IsError { + t.Fatalf("Expand failed: %s", result.ForLLM) + } + + // Parse result + var output struct { + Success bool `json:"success"` + TokenCount int `json:"tokenCount"` + Messages []map[string]any `json:"messages"` + } + if err := json.Unmarshal([]byte(result.ForLLM), &output); err != nil { + t.Fatalf("Parse result: %v", err) + } + + if !output.Success { + t.Error("expected success=true") + } + if len(output.Messages) != 2 { + t.Errorf("Messages = %d, want 2", len(output.Messages)) + } + if output.TokenCount != 20 { + t.Errorf("TokenCount = %d, want 20", output.TokenCount) + } +} + +func TestExpandToolMissingIDs(t *testing.T) { + s := openTestStore(t) + re := &RetrievalEngine{store: s} + tool := NewExpandTool(re) + + result := tool.Execute(context.Background(), map[string]any{}) + + if !result.IsError { + t.Error("expected error for missing message_ids") + } +} + +func TestExpandToolWithParts(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "test:expand-parts") + + // Create message with parts + parts := []MessagePart{ + {Type: "text", Text: "Hello"}, + {Type: "tool_use", Name: "bash", Arguments: `{"command":"ls"}`, ToolCallID: "call_123"}, + {Type: "tool_result", ToolCallID: "call_123", Text: "file1.txt\nfile2.txt"}, + } + msg, _ := s.AddMessageWithParts(ctx, conv.ConversationID, "assistant", parts, 50) + + re := &RetrievalEngine{store: s} + tool := NewExpandTool(re) + + result := tool.Execute(ctx, map[string]any{ + "message_ids": []any{fmt.Sprintf("%d", msg.ID)}, + }) + + if result.IsError { + t.Fatalf("Expand failed: %s", result.ForLLM) + } + + var output struct { + Messages []struct { + Parts []map[string]any `json:"parts"` + } `json:"messages"` + } + if err := json.Unmarshal([]byte(result.ForLLM), &output); err != nil { + t.Fatalf("Parse result: %v", err) + } + + if len(output.Messages) != 1 { + t.Fatalf("Messages = %d, want 1", len(output.Messages)) + } + + // Verify parts are filtered correctly + foundText := false + foundToolUse := false + foundToolResult := false + for _, p := range output.Messages[0].Parts { + switch p["type"].(string) { + case "text": + foundText = true + if p["text"] != "Hello" { + t.Errorf("text = %v, want Hello", p["text"]) + } + case "tool_use": + foundToolUse = true + if p["name"] != "bash" { + t.Errorf("name = %v, want bash", p["name"]) + } + case "tool_result": + foundToolResult = true + // tool_result should NOT have content + if _, hasContent := p["content"]; hasContent { + t.Error("tool_result should not have content field") + } + if p["toolCallId"] != "call_123" { + t.Errorf("toolCallId = %v, want call_123", p["toolCallId"]) + } + } + } + + if !foundText { + t.Error("missing text part") + } + if !foundToolUse { + t.Error("missing tool_use part") + } + if !foundToolResult { + t.Error("missing tool_result part") + } +} diff --git a/pkg/seahorse/tool_grep.go b/pkg/seahorse/tool_grep.go new file mode 100644 index 000000000..6502fc5c3 --- /dev/null +++ b/pkg/seahorse/tool_grep.go @@ -0,0 +1,172 @@ +package seahorse + +import ( + "context" + "encoding/json" + "fmt" + "time" + + "github.com/sipeed/picoclaw/pkg/tools" +) + +// GrepTool searches summaries and messages for matching content. +type GrepTool struct { + engine *RetrievalEngine +} + +func NewGrepTool(engine *RetrievalEngine) *GrepTool { + return &GrepTool{engine: engine} +} + +func (t *GrepTool) Name() string { + return "short_grep" +} + +func (t *GrepTool) Description() string { + return `Search summaries and messages for matching content. + +Pattern syntax: +- Words: "authentication" - matches content containing this word +- AND: "auth AND login" - matches content with both words +- OR: "auth OR signin" - matches content with either word +- NOT: "bug NOT fixed" - matches "bug" but excludes "fixed" +- Wildcard: "%auth%" - matches any text containing "auth" (e.g., "auth", "authentication") + +Each summary has a "depth" field: +- depth 0: Created from messages, most detailed +- depth 1+: Created from other summaries, more compressed but covers longer time + +Parameters: +- pattern (required): Search pattern +- scope: "both" (default), "summary", or "message" - what to search +- role: "user", "assistant", or omit for all - filter by message role +- last: Time shortcut like "6h", "7d", "2w", "1m" (hours/days/weeks/months) +- all_conversations: Search all conversations (default: current only) +- since: ISO8601 timestamp, content after this time +- before: ISO8601 timestamp, content before this time +- limit: Max results (default: 20) + +Returns: +{ + "success": true, + "summaries": [{"id": "sum_abc", "content": "...", "depth": 0, "kind": "leaf", "conversationId": 1, "rank": -0.5}], + "messages": [{"id": "10", "snippet": "...matched...", "role": "user", "conversationId": 1, "rank": -1.2}], + "totalSummaries": 5, + "totalMessages": 10, + "hint": "No matches. Try: %keyword% for fuzzy search" +} + +Rank field (FTS5 mode only): bm25 relevance score, negative value where closer to 0 = better match. +Examples: -0.5=excellent, -2=good, -5=partial, -10=weak. LIKE mode (%pattern%) has no rank. + +Examples: + {"pattern": "authentication"} + {"pattern": "bug AND login"} + {"pattern": "%snake%"} + {"pattern": "project", "scope": "summary"} + {"pattern": "error", "role": "assistant", "last": "7d"} + {"pattern": "error", "all_conversations": true}` +} + +func (t *GrepTool) Parameters() map[string]any { + return map[string]any{ + "type": "object", + "properties": map[string]any{ + "pattern": map[string]any{ + "type": "string", + "description": "Search pattern. Supports: words, AND/OR/NOT operators, % wildcard", + }, + "scope": map[string]any{ + "type": "string", + "enum": []string{"both", "summary", "message"}, + "description": "What to search: 'both' (default), 'summary', or 'message'", + }, + "role": map[string]any{ + "type": "string", + "enum": []string{"user", "assistant"}, + "description": "Filter by message role (default: all roles)", + }, + "last": map[string]any{ + "type": "string", + "description": "Time shortcut: '6h' (6 hours), '7d' (7 days), '2w' (2 weeks), '1m' (1 month)", + }, + "all_conversations": map[string]any{ + "type": "boolean", + "description": "Search across all conversations (default: searches current conversation only)", + }, + "since": map[string]any{ + "type": "string", + "description": "ISO8601 timestamp, only return content after this time", + }, + "before": map[string]any{ + "type": "string", + "description": "ISO8601 timestamp, only return content before this time", + }, + "limit": map[string]any{ + "type": "integer", + "description": "Maximum number of results (default: 20)", + }, + }, + "required": []string{"pattern"}, + } +} + +func (t *GrepTool) Execute(ctx context.Context, args map[string]any) *tools.ToolResult { + pattern, ok := args["pattern"].(string) + if !ok || pattern == "" { + return tools.ErrorResult("Missing required 'pattern' argument. Example: {\"pattern\": \"authentication\"}") + } + + input := GrepInput{Pattern: pattern} + + if scope, ok := args["scope"].(string); ok && scope != "" { + input.Scope = scope + } + if role, ok := args["role"].(string); ok && role != "" { + input.Role = role + } + if last, ok := args["last"].(string); ok && last != "" { + input.Last = last + } + if allConv, ok := args["all_conversations"].(bool); ok { + input.AllConversations = allConv + } + if limit, ok := args["limit"].(float64); ok { + input.Limit = int(limit) + } + if sinceStr, ok := args["since"].(string); ok && sinceStr != "" { + parsed, err := time.Parse(time.RFC3339, sinceStr) + if err != nil { + return tools.ErrorResult(fmt.Sprintf( + "Invalid 'since' timestamp. Use RFC3339 format like '2024-01-15T10:00:00Z'. Error: %v", err)) + } + input.Since = &parsed + } + if beforeStr, ok := args["before"].(string); ok && beforeStr != "" { + parsed, err := time.Parse(time.RFC3339, beforeStr) + if err != nil { + return tools.ErrorResult(fmt.Sprintf("Invalid 'before' timestamp format: %v", err)) + } + input.Before = &parsed + } + + result, err := t.engine.Grep(ctx, input) + if err != nil { + return tools.ErrorResult("Grep failed: " + err.Error()) + } + + // Build response + output := map[string]any{ + "success": result.Success, + "summaries": result.Summaries, + "messages": result.Messages, + } + + // Add hint if provided + if result.Hint != "" { + output["hint"] = result.Hint + } + + data, _ := json.Marshal(output) + return tools.NewToolResult(string(data)) +} diff --git a/pkg/seahorse/tool_grep_test.go b/pkg/seahorse/tool_grep_test.go new file mode 100644 index 000000000..050d9deeb --- /dev/null +++ b/pkg/seahorse/tool_grep_test.go @@ -0,0 +1,72 @@ +package seahorse + +import ( + "context" + "testing" +) + +func TestGrepSearchSummaries(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "test:grep-tool") + + s.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "database connection pool configuration", + TokenCount: 50, + }) + + re := &RetrievalEngine{store: s} + results, err := re.Grep(ctx, GrepInput{ + Pattern: "database", + }) + if err != nil { + t.Fatalf("Grep: %v", err) + } + if len(results.Summaries) == 0 { + t.Error("expected at least 1 summary result") + } +} + +func TestGrepSearchMessages(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + conv, _ := s.GetOrCreateConversation(ctx, "test:grep-msg") + + s.AddMessage(ctx, conv.ConversationID, "user", "find this message about testing", 5) + s.AddMessage(ctx, conv.ConversationID, "user", "unrelated content", 3) + + re := &RetrievalEngine{store: s} + results, err := re.Grep(ctx, GrepInput{ + Pattern: "testing", + }) + if err != nil { + t.Fatalf("Grep messages: %v", err) + } + if len(results.Messages) == 0 { + t.Error("expected at least 1 message result") + } +} + +func TestGrepMissingPattern(t *testing.T) { + s := openTestStore(t) + re := &RetrievalEngine{store: s} + _, err := re.Grep(context.Background(), GrepInput{}) + if err == nil { + t.Error("expected error for missing pattern") + } +} + +func TestGrepToolSupportsAllConversations(t *testing.T) { + s := openTestStore(t) + tool := NewGrepTool(&RetrievalEngine{store: s}) + params := tool.Parameters() + props := params["properties"].(map[string]any) + + // GrepTool should accept all_conversations parameter + if _, ok := props["all_conversations"]; !ok { + t.Error("Parameters missing 'all_conversations' field") + } +} diff --git a/pkg/seahorse/types.go b/pkg/seahorse/types.go new file mode 100644 index 000000000..2bc7f931f --- /dev/null +++ b/pkg/seahorse/types.go @@ -0,0 +1,161 @@ +package seahorse + +import ( + "time" + + "github.com/sipeed/picoclaw/pkg/providers" + "github.com/sipeed/picoclaw/pkg/tokenizer" +) + +// SummaryKind distinguishes leaf summaries (from raw messages) vs condensed +// summaries (from other summaries). +type SummaryKind string + +const ( + SummaryKindLeaf SummaryKind = "leaf" + SummaryKindCondensed SummaryKind = "condensed" +) + +// Message represents a single chat message with role and content. +type Message struct { + ID int64 `json:"id"` + ConversationID int64 `json:"conversationId"` + Role string `json:"role"` + Content string `json:"content"` + ReasoningContent string `json:"reasoningContent,omitempty"` + TokenCount int `json:"tokenCount"` + CreatedAt time.Time `json:"createdAt"` + Parts []MessagePart `json:"parts,omitempty"` +} + +// MessagePart holds structured content (tool calls, media, etc.) +type MessagePart struct { + ID int64 `json:"id"` + MessageID int64 `json:"messageId"` + Type string `json:"type"` // "text", "tool_use", "tool_result", "media" + Text string `json:"text"` + Name string `json:"name"` + Arguments string `json:"arguments"` + ToolCallID string `json:"toolCallId"` + MediaURI string `json:"mediaUri"` + MimeType string `json:"mimeType"` +} + +// Summary represents a compressed representation of messages or other summaries. +type Summary struct { + SummaryID string `json:"summaryId"` + ConversationID int64 `json:"conversationId"` + Kind SummaryKind `json:"kind"` + Depth int `json:"depth"` + Content string `json:"content"` + TokenCount int `json:"tokenCount"` + EarliestAt *time.Time `json:"earliestAt,omitempty"` + LatestAt *time.Time `json:"latestAt,omitempty"` + DescendantCount int `json:"descendantCount"` + DescendantTokenCount int `json:"descendantTokenCount"` + SourceMessageTokenCount int `json:"sourceMessageTokenCount"` + Model string `json:"model"` + CreatedAt time.Time `json:"createdAt"` +} + +// SummaryNode is a Summary with graph relationships for tree traversal. +type SummaryNode struct { + Summary + Children []string `json:"children"` // Child summary IDs + Expanded bool `json:"expanded"` // UI state for expansion +} + +// Conversation represents a session's conversation with metadata. +type Conversation struct { + ConversationID int64 `json:"conversationId"` + SessionKey string `json:"sessionKey"` + CreatedAt time.Time `json:"createdAt"` + UpdatedAt time.Time `json:"updatedAt"` +} + +// SessionStatus contains status information for a session. +type SessionStatus struct { + SessionKey string `json:"sessionKey"` + ConversationID int64 `json:"conversationId"` + Messages int `json:"messages"` + TotalTokens int `json:"totalTokens"` + Summaries int `json:"summaries"` + OldestAt time.Time `json:"oldestAt"` + NewestAt time.Time `json:"newestAt"` +} + +// ContextItem represents one item in the assembled context window. +type ContextItem struct { + ConversationID int64 `json:"conversationId"` + Ordinal int `json:"ordinal"` + ItemType string `json:"itemType"` // "summary" or "message" + SummaryID string `json:"summaryId,omitempty"` + MessageID int64 `json:"messageId,omitempty"` + TokenCount int `json:"tokenCount"` + CreatedAt time.Time `json:"createdAt"` +} + +// SummarySubtreeNode is a node in a summary DAG subtree. +type SummarySubtreeNode struct { + SummaryID string `json:"summaryId"` + DepthFromRoot int `json:"depthFromRoot"` +} + +// SearchInput controls summary search. +type SearchInput struct { + Pattern string `json:"pattern"` + Mode string `json:"mode"` // "like" (LIKE search) or "full_text" (FTS5, default) + Scope string `json:"scope,omitempty"` // "messages", "summaries", "both" + Role string `json:"role,omitempty"` // "user", "assistant", or "" (all) + Since *time.Time `json:"since,omitempty"` + Before *time.Time `json:"before,omitempty"` + Limit int `json:"limit,omitempty"` + ConversationID int64 `json:"conversationId,omitempty"` + AllConversations bool `json:"allConversations,omitempty"` +} + +// SearchResult is a search match. +type SearchResult struct { + SummaryID string `json:"summaryId,omitempty"` + MessageID int64 `json:"messageId,omitempty"` + ConversationID int64 `json:"conversationId"` + Kind SummaryKind `json:"kind,omitempty"` + Depth int `json:"depth,omitempty"` + Role string `json:"role,omitempty"` + Content string `json:"content,omitempty"` // Full content for summaries + Snippet string `json:"snippet"` + CreatedAt time.Time `json:"createdAt"` + Rank float64 `json:"rank,omitempty"` + TotalCount int `json:"totalCount,omitempty"` // Total matching rows (from window function) +} + +// EstimateMessageTokens estimates token count for a full message using the +// shared tokenizer package for consistency with agent.context_budget. +func EstimateMessageTokens(msg Message) int { + pm := providers.Message{ + Role: msg.Role, + Content: msg.Content, + ReasoningContent: msg.ReasoningContent, + } + + // Convert MessageParts to ToolCalls / ToolCallID / Media + for _, part := range msg.Parts { + switch part.Type { + case "tool_use": + pm.ToolCalls = append(pm.ToolCalls, providers.ToolCall{ + ID: part.ToolCallID, + Type: "function", + Function: &providers.FunctionCall{ + Name: part.Name, + Arguments: part.Arguments, + }, + }) + case "tool_result": + pm.ToolCallID = part.ToolCallID + case "media": + pm.Media = append(pm.Media, part.MediaURI) + } + } + + return tokenizer.EstimateMessageTokens(pm) +} diff --git a/pkg/seahorse/types_test.go b/pkg/seahorse/types_test.go new file mode 100644 index 000000000..b7467005f --- /dev/null +++ b/pkg/seahorse/types_test.go @@ -0,0 +1,54 @@ +package seahorse + +import ( + "testing" +) + +func TestSummaryKindValues(t *testing.T) { + if SummaryKindLeaf != "leaf" { + t.Errorf("expected SummaryKindLeaf = 'leaf', got %q", SummaryKindLeaf) + } + if SummaryKindCondensed != "condensed" { + t.Errorf("expected SummaryKindCondensed = 'condensed', got %q", SummaryKindCondensed) + } +} + +func TestConstants(t *testing.T) { + // Ordinal gap step + if OrdinalStep != 100 { + t.Errorf("expected OrdinalStep = 100, got %d", OrdinalStep) + } + + // Compaction triggers + if ContextThreshold != 0.75 { + t.Errorf("expected ContextThreshold = 0.75, got %f", ContextThreshold) + } + if FreshTailCount != 32 { + t.Errorf("expected FreshTailCount = 32, got %d", FreshTailCount) + } + + // Fanout + if LeafMinFanout != 8 { + t.Errorf("expected LeafMinFanout = 8, got %d", LeafMinFanout) + } + if CondensedMinFanout != 4 { + t.Errorf("expected CondensedMinFanout = 4, got %d", CondensedMinFanout) + } + if CondensedMinFanoutHard != 2 { + t.Errorf("expected CondensedMinFanoutHard = 2, got %d", CondensedMinFanoutHard) + } + + // Token targets + if LeafChunkTokens != 20000 { + t.Errorf("expected LeafChunkTokens = 20000, got %d", LeafChunkTokens) + } + if LeafTargetTokens != 1200 { + t.Errorf("expected LeafTargetTokens = 1200, got %d", LeafTargetTokens) + } + if CondensedTargetTokens != 2000 { + t.Errorf("expected CondensedTargetTokens = 2000, got %d", CondensedTargetTokens) + } + if MaxExpandTokens != 4000 { + t.Errorf("expected MaxExpandTokens = 4000, got %d", MaxExpandTokens) + } +} diff --git a/pkg/session/jsonl_backend.go b/pkg/session/jsonl_backend.go index 7f470de15..5a2297e30 100644 --- a/pkg/session/jsonl_backend.go +++ b/pkg/session/jsonl_backend.go @@ -79,3 +79,8 @@ func (b *JSONLBackend) Save(key string) error { func (b *JSONLBackend) Close() error { return b.store.Close() } + +// ListSessions returns all known session keys. +func (b *JSONLBackend) ListSessions() []string { + return b.store.ListSessions() +} diff --git a/pkg/session/manager.go b/pkg/session/manager.go index ef720b7c5..7f87d460a 100644 --- a/pkg/session/manager.go +++ b/pkg/session/manager.go @@ -145,6 +145,16 @@ func (sm *SessionManager) TruncateHistory(key string, keepLast int) { session.Updated = time.Now() } +func (sm *SessionManager) ListSessions() []string { + sm.mu.RLock() + defer sm.mu.RUnlock() + keys := make([]string, 0, len(sm.sessions)) + for k := range sm.sessions { + keys = append(keys, k) + } + return keys +} + // sanitizeFilename converts a session key into a cross-platform safe filename. // Replaces ':' with '_' (session key separator) and '/' and '\' with '_' so // composite IDs (e.g. Telegram forum "chatID/threadID") do not create diff --git a/pkg/session/session_store.go b/pkg/session/session_store.go index 1d1a2f967..2ba2a974d 100644 --- a/pkg/session/session_store.go +++ b/pkg/session/session_store.go @@ -27,6 +27,8 @@ type SessionStore interface { TruncateHistory(key string, keepLast int) // Save persists any pending state to durable storage. Save(key string) error + // ListSessions returns all known session keys. + ListSessions() []string // Close releases resources held by the store. Close() error } diff --git a/pkg/tokenizer/estimator.go b/pkg/tokenizer/estimator.go new file mode 100644 index 000000000..3265edaa8 --- /dev/null +++ b/pkg/tokenizer/estimator.go @@ -0,0 +1,91 @@ +package tokenizer + +import ( + "encoding/json" + "unicode/utf8" + + "github.com/sipeed/picoclaw/pkg/providers" +) + +// EstimateMessageTokens estimates the token count for a single message, +// including Content, ReasoningContent, ToolCalls arguments, ToolCallID +// metadata, and Media items. Uses a heuristic of 2.5 characters per token. +func EstimateMessageTokens(msg providers.Message) int { + contentChars := utf8.RuneCountInString(msg.Content) + + // SystemParts are structured system blocks used for cache-aware adapters. + // They carry the same content as Content, but in multiple blocks. + // We estimate them as an alternative representation, not additive. + systemPartsChars := 0 + if len(msg.SystemParts) > 0 { + for _, part := range msg.SystemParts { + systemPartsChars += utf8.RuneCountInString(part.Text) + } + // Per-part overhead for JSON structure (type, text, cache_control). + const perPartOverhead = 20 + systemPartsChars += len(msg.SystemParts) * perPartOverhead + } + + // Use the larger of the two representations to stay conservative. + chars := contentChars + if systemPartsChars > chars { + chars = systemPartsChars + } + + chars += utf8.RuneCountInString(msg.ReasoningContent) + + for _, tc := range msg.ToolCalls { + chars += len(tc.ID) + len(tc.Type) + if tc.Function != nil { + // Count function name + arguments (the wire format for most providers). + // tc.Name mirrors tc.Function.Name — count only once to avoid double-counting. + chars += len(tc.Function.Name) + len(tc.Function.Arguments) + } else { + // Fallback: some provider formats use top-level Name without Function. + chars += len(tc.Name) + } + } + + if msg.ToolCallID != "" { + chars += len(msg.ToolCallID) + } + + // Per-message overhead for role label, JSON structure, separators. + const messageOverhead = 12 + chars += messageOverhead + + tokens := chars * 2 / 5 + + // Media items (images, files) are serialized by provider adapters into + // multipart or image_url payloads. Add a fixed per-item token estimate + // directly (not through the chars heuristic) since actual cost depends + // on resolution and provider-specific image tokenization. + const mediaTokensPerItem = 256 + tokens += len(msg.Media) * mediaTokensPerItem + + return tokens +} + +// EstimateToolDefsTokens estimates the total token cost of tool definitions +// as they appear in the LLM request. +func EstimateToolDefsTokens(defs []providers.ToolDefinition) int { + if len(defs) == 0 { + return 0 + } + + totalChars := 0 + for _, d := range defs { + totalChars += len(d.Function.Name) + len(d.Function.Description) + + if d.Function.Parameters != nil { + if paramJSON, err := json.Marshal(d.Function.Parameters); err == nil { + totalChars += len(paramJSON) + } + } + + // Per-tool overhead: type field, JSON structure, separators. + totalChars += 20 + } + + return totalChars * 2 / 5 +} From 1175f4a62b2acf10a6e236cc62b12ade5e8134fd Mon Sep 17 00:00:00 2001 From: Liu Yuan Date: Mon, 6 Apr 2026 17:26:43 +0800 Subject: [PATCH 020/174] feat(membench): add LOCOMO memory benchmark tool (#2353) Benchmark tool comparing legacy session manager vs seahorse short memory retrieval on the LOCOMO long-term conversational memory dataset. - cmd/membench/: CLI with ingest/eval/report/run subcommands - Mode A (legacy): recency-biased budget truncation baseline - Mode B (seahorse): per-keyword trigram FTS5 search + expand - Metrics: Token-Overlap F1 and Recall Hit Rate - `make mem` builds, downloads data, runs benchmark end-to-end --- Makefile | 19 ++ cmd/membench/eval.go | 366 +++++++++++++++++++++++++++++++++++ cmd/membench/eval_test.go | 104 ++++++++++ cmd/membench/ingest.go | 85 ++++++++ cmd/membench/ingest_test.go | 79 ++++++++ cmd/membench/legacy_store.go | 34 ++++ cmd/membench/locomo.go | 142 ++++++++++++++ cmd/membench/locomo_test.go | 67 +++++++ cmd/membench/main.go | 208 ++++++++++++++++++++ cmd/membench/metrics.go | 227 ++++++++++++++++++++++ cmd/membench/metrics_test.go | 239 +++++++++++++++++++++++ go.mod | 1 + go.sum | 2 + 13 files changed, 1573 insertions(+) create mode 100644 cmd/membench/eval.go create mode 100644 cmd/membench/eval_test.go create mode 100644 cmd/membench/ingest.go create mode 100644 cmd/membench/ingest_test.go create mode 100644 cmd/membench/legacy_store.go create mode 100644 cmd/membench/locomo.go create mode 100644 cmd/membench/locomo_test.go create mode 100644 cmd/membench/main.go create mode 100644 cmd/membench/metrics.go create mode 100644 cmd/membench/metrics_test.go diff --git a/Makefile b/Makefile index 4704b7c4a..f7ebc7411 100644 --- a/Makefile +++ b/Makefile @@ -349,6 +349,25 @@ build-macos-app:build-launcher @./scripts/build-macos-app.sh $(PLATFORM)-$(ARCH) @echo "macOS .app bundle created: $(BUILD_DIR)/PicoClaw.app" +## mem: Build membench, download LOCOMO data (if needed), run benchmark, and show results +mem: + @echo "Building membench..." + @mkdir -p $(BUILD_DIR) + @$(GO) build -o $(BUILD_DIR)/membench ./cmd/membench + @echo "Build complete: $(BUILD_DIR)/membench" + @if [ ! -f $(BUILD_DIR)/memdata/locomo10.json ]; then \ + echo "Downloading LOCOMO dataset..."; \ + mkdir -p $(BUILD_DIR)/memdata; \ + curl -sfL "https://raw.githubusercontent.com/snap-research/locomo/main/data/locomo10.json" \ + -o $(BUILD_DIR)/memdata/locomo10.json && [ -s $(BUILD_DIR)/memdata/locomo10.json ] || { echo "Error: LOCOMO download failed"; exit 1; }; \ + echo "Download complete"; \ + else \ + echo "LOCOMO dataset already exists, skipping download"; \ + fi + @echo "Running benchmark..." + @rm -rf $(BUILD_DIR)/memout + @$(BUILD_DIR)/membench run --data $(BUILD_DIR)/memdata --out $(BUILD_DIR)/memout --budget 4000 + ## help: Show this help message help: @echo "picoclaw Makefile" diff --git a/cmd/membench/eval.go b/cmd/membench/eval.go new file mode 100644 index 000000000..bddee76fd --- /dev/null +++ b/cmd/membench/eval.go @@ -0,0 +1,366 @@ +package main + +import ( + "context" + "encoding/json" + "fmt" + "log" + "os" + "path/filepath" + "sort" + "strings" + + "github.com/sipeed/picoclaw/pkg/seahorse" +) + +// EvalResult holds per-sample evaluation results for one mode. +type EvalResult struct { + Mode string `json:"mode"` + SampleID string `json:"sampleId"` + QAResults []QAResult `json:"qaResults"` + Agg AggMetrics `json:"aggregated"` +} + +// QAResult holds metrics for a single QA pair. +type QAResult struct { + Question string `json:"question"` + Category int `json:"category"` + GoldAnswer string `json:"goldAnswer"` + TokenF1 float64 `json:"tokenF1"` + HitRate float64 `json:"hitRate"` +} + +// AggMetrics holds aggregated evaluation metrics. +type AggMetrics struct { + OverallF1 float64 `json:"overallF1"` + OverallHitRate float64 `json:"overallHitRate"` + ByCategory map[int]*CatMetrics `json:"byCategory"` + TotalQuestions int `json:"totalQuestions"` +} + +// CatMetrics holds metrics for a single category. +type CatMetrics struct { + F1 float64 `json:"f1"` + HitRate float64 `json:"hitRate"` + QuestionCount int `json:"questionCount"` +} + +// EvalLegacy evaluates using legacy session store (raw history + budget truncation). +func EvalLegacy( + ctx context.Context, + samples []LocomoSample, + legacy *LegacyStore, + budgetTokens int, +) []EvalResult { + results := make([]EvalResult, 0, len(samples)) + for si := range samples { + sample := &samples[si] + history := legacy.GetHistory(sample.SampleID) + + // Convert messages to content strings + allContent := make([]string, 0, len(history)) + for _, msg := range history { + allContent = append(allContent, msg.Content) + } + + qaResults := make([]QAResult, 0, len(sample.QA)) + for qi := range sample.QA { + qa := &sample.QA[qi] + // Budget truncate the full history + truncated, _ := BudgetTruncate(allContent, budgetTokens) + context := StringListToContent(truncated) + + f1 := TokenOverlapF1(context, qa.AnswerString()) + hitRate := RecallHitRate(qa.Evidence, sample, context) + + qaResults = append(qaResults, QAResult{ + Question: qa.Question, + Category: qa.Category, + GoldAnswer: qa.AnswerString(), + TokenF1: f1, + HitRate: hitRate, + }) + } + + results = append(results, EvalResult{ + Mode: "legacy", + SampleID: sample.SampleID, + QAResults: qaResults, + Agg: aggregateMetrics(qaResults), + }) + } + return results +} + +// EvalSeahorse evaluates using seahorse short memory (per-keyword search + expand). +func EvalSeahorse( + ctx context.Context, + samples []LocomoSample, + ir *SeahorseIngestResult, + budgetTokens int, +) []EvalResult { + store := ir.Engine.GetRetrieval().Store() + retrieval := ir.Engine.GetRetrieval() + + results := make([]EvalResult, 0, len(samples)) + for si := range samples { + sample := &samples[si] + convID, ok := ir.ConvMap[sample.SampleID] + if !ok { + log.Printf("WARN: no conversation ID for sample %s", sample.SampleID) + continue + } + + qaResults := make([]QAResult, 0, len(sample.QA)) + for qi := range sample.QA { + qa := &sample.QA[qi] + keywords := ExtractKeywords(qa.Question) + + // Search each keyword individually and union results, + // tracking best BM25 rank per message for relevance sorting. + bestRank := map[int64]float64{} + for _, kw := range keywords { + searchResults, err := store.SearchMessages(ctx, seahorse.SearchInput{ + Pattern: kw, + ConversationID: convID, + Limit: 20, + }) + if err != nil { + log.Printf("WARN: search failed for keyword %q: %v", kw, err) + continue + } + for _, sr := range searchResults { + if sr.MessageID > 0 { + if prev, ok := bestRank[sr.MessageID]; !ok || sr.Rank < prev { + bestRank[sr.MessageID] = sr.Rank + } + } + } + } + // Sort messageIDs by rank ascending (best/most-negative first). + // BudgetTruncate walks from the front, keeping best-ranked messages. + // Note: SQLite FTS5 bm25() returns negative values where more + // negative = better match. + messageIDs := make([]int64, 0, len(bestRank)) + for id := range bestRank { + messageIDs = append(messageIDs, id) + } + sort.Slice(messageIDs, func(i, j int) bool { + return bestRank[messageIDs[i]] < bestRank[messageIDs[j]] + }) + + // Expand messages to get full content + var contentParts []string + if len(messageIDs) > 0 { + expandResult, err := retrieval.ExpandMessages(ctx, messageIDs) + if err != nil { + log.Printf("WARN: expand failed for sample %s: %v", sample.SampleID, err) + } else { + for _, msg := range expandResult.Messages { + contentParts = append(contentParts, msg.Content) + } + } + } + + if len(contentParts) == 0 { + qaResults = append(qaResults, QAResult{ + Question: qa.Question, + Category: qa.Category, + GoldAnswer: qa.AnswerString(), + TokenF1: 0.0, + HitRate: 0.0, + }) + continue + } + + // Budget truncate (drop worst-ranked) + truncated, _ := BudgetTruncate(contentParts, budgetTokens) + context := StringListToContent(truncated) + + f1 := TokenOverlapF1(context, qa.AnswerString()) + hitRate := RecallHitRate(qa.Evidence, sample, context) + + qaResults = append(qaResults, QAResult{ + Question: qa.Question, + Category: qa.Category, + GoldAnswer: qa.AnswerString(), + TokenF1: f1, + HitRate: hitRate, + }) + } + + results = append(results, EvalResult{ + Mode: "seahorse", + SampleID: sample.SampleID, + QAResults: qaResults, + Agg: aggregateMetrics(qaResults), + }) + } + return results +} + +// aggregateMetrics computes overall and per-category metrics. +func aggregateMetrics(qaResults []QAResult) AggMetrics { + byCat := map[int]*CatMetrics{} + totalF1 := 0.0 + totalHitRate := 0.0 + for _, qr := range qaResults { + totalF1 += qr.TokenF1 + totalHitRate += qr.HitRate + cat, ok := byCat[qr.Category] + if !ok { + cat = &CatMetrics{} + byCat[qr.Category] = cat + } + cat.F1 += qr.TokenF1 + cat.HitRate += qr.HitRate + cat.QuestionCount++ + } + n := len(qaResults) + if n == 0 { + n = 1 + } + agg := AggMetrics{ + OverallF1: totalF1 / float64(n), + OverallHitRate: totalHitRate / float64(n), + ByCategory: byCat, + TotalQuestions: len(qaResults), + } + for _, cat := range agg.ByCategory { + if cat.QuestionCount > 0 { + cat.F1 /= float64(cat.QuestionCount) + cat.HitRate /= float64(cat.QuestionCount) + } + } + return agg +} + +// SaveResults writes per-sample eval results to JSON files. +func SaveResults(results []EvalResult, outDir string) error { + if err := os.MkdirAll(outDir, 0o755); err != nil { + return fmt.Errorf("create output dir: %w", err) + } + for _, r := range results { + path := filepath.Join(outDir, fmt.Sprintf("eval_%s_%s.json", r.Mode, r.SampleID)) + data, err := json.MarshalIndent(r, "", " ") + if err != nil { + return fmt.Errorf("marshal result: %w", err) + } + if err := os.WriteFile(path, data, 0o644); err != nil { + return fmt.Errorf("write result: %w", err) + } + } + return nil +} + +// SaveAggregated writes a combined results.json with all modes. +func SaveAggregated(results []EvalResult, outDir string) error { + byMode := map[string][]EvalResult{} + for _, r := range results { + byMode[r.Mode] = append(byMode[r.Mode], r) + } + + aggMap := map[string]AggMetrics{} + for mode, modeResults := range byMode { + aggMap[mode] = computeModeAgg(modeResults) + } + + data, err := json.MarshalIndent(aggMap, "", " ") + if err != nil { + return err + } + return os.WriteFile(filepath.Join(outDir, "results.json"), data, 0o644) +} + +// computeModeAgg aggregates results for a single mode using weighted averaging +// (weighted by question count per sample). All modes must have the same Mode field. +func computeModeAgg(results []EvalResult) AggMetrics { + agg := AggMetrics{ByCategory: map[int]*CatMetrics{}} + for _, r := range results { + agg.OverallF1 += r.Agg.OverallF1 * float64(r.Agg.TotalQuestions) + agg.OverallHitRate += r.Agg.OverallHitRate * float64(r.Agg.TotalQuestions) + agg.TotalQuestions += r.Agg.TotalQuestions + for cat, cm := range r.Agg.ByCategory { + existing, ok := agg.ByCategory[cat] + if !ok { + existing = &CatMetrics{} + agg.ByCategory[cat] = existing + } + existing.F1 += cm.F1 * float64(cm.QuestionCount) + existing.HitRate += cm.HitRate * float64(cm.QuestionCount) + existing.QuestionCount += cm.QuestionCount + } + } + if agg.TotalQuestions > 0 { + agg.OverallF1 /= float64(agg.TotalQuestions) + agg.OverallHitRate /= float64(agg.TotalQuestions) + } + for _, cat := range agg.ByCategory { + if cat.QuestionCount > 0 { + cat.F1 /= float64(cat.QuestionCount) + cat.HitRate /= float64(cat.QuestionCount) + } + } + return agg +} + +// printSection prints a single comparison table section. +func printSection(title string, results []EvalResult) { + fmt.Printf("\n--- %s ---\n", title) + byMode := map[string][]EvalResult{} + for _, r := range results { + byMode[r.Mode] = append(byMode[r.Mode], r) + } + + modes := map[string]AggMetrics{} + for mode, modeResults := range byMode { + modes[mode] = computeModeAgg(modeResults) + } + + modeKeys := make([]string, 0, len(modes)) + for k := range modes { + modeKeys = append(modeKeys, k) + } + sort.Strings(modeKeys) + + // Collect all category keys across modes + catSet := map[int]bool{} + for _, agg := range modes { + for cat := range agg.ByCategory { + catSet[cat] = true + } + } + cats := make([]int, 0, len(catSet)) + for cat := range catSet { + cats = append(cats, cat) + } + sort.Ints(cats) + + fmt.Printf("%-10s %-8s %-8s", "Mode", "HitRate", "F1") + for _, cat := range cats { + fmt.Printf(" %-7s", fmt.Sprintf("C%d", cat)) + } + fmt.Println() + fmt.Println(strings.Repeat("-", 10+8+8+7*len(cats)+8)) + + for _, mode := range modeKeys { + agg := modes[mode] + fmt.Printf("%-10s %-8.4f %-8.4f", mode, agg.OverallHitRate, agg.OverallF1) + for _, cat := range cats { + if cm, ok := agg.ByCategory[cat]; ok { + fmt.Printf(" %-7.4f", cm.HitRate) + } else { + fmt.Printf(" %-7s", "N/A") + } + } + fmt.Println() + } +} + +// PrintComparison outputs a human-readable comparison table to stdout. +func PrintComparison(results []EvalResult, llmResults []EvalResult) { + printSection("No LLM generation", results) + if len(llmResults) > 0 { + printSection("With LLM", llmResults) + } +} diff --git a/cmd/membench/eval_test.go b/cmd/membench/eval_test.go new file mode 100644 index 000000000..d500a38ca --- /dev/null +++ b/cmd/membench/eval_test.go @@ -0,0 +1,104 @@ +package main + +import ( + "math" + "testing" +) + +func TestComputeModeAggAllCategories(t *testing.T) { + results := []EvalResult{ + { + Mode: "test", + SampleID: "s1", + QAResults: []QAResult{ + {Category: 1, TokenF1: 0.5, HitRate: 0.8}, + {Category: 2, TokenF1: 0.3, HitRate: 0.6}, + {Category: 3, TokenF1: 0.1, HitRate: 0.4}, + {Category: 4, TokenF1: 0.7, HitRate: 0.9}, + {Category: 5, TokenF1: 0.2, HitRate: 0.1}, + }, + }, + } + for i := range results { + results[i].Agg = aggregateMetrics(results[i].QAResults) + } + + got := computeModeAgg(results) + + // Should have all 5 categories + for cat := 1; cat <= 5; cat++ { + cm, ok := got.ByCategory[cat] + if !ok { + t.Errorf("ByCategory missing category %d", cat) + continue + } + if cm.QuestionCount != 1 { + t.Errorf("ByCategory[%d].QuestionCount = %d, want 1", cat, cm.QuestionCount) + } + } + + // Verify specific F1 values per category + wantF1 := map[int]float64{1: 0.5, 2: 0.3, 3: 0.1, 4: 0.7, 5: 0.2} + for cat, want := range wantF1 { + if cm, ok := got.ByCategory[cat]; ok { + if math.Abs(cm.F1-want) > 1e-9 { + t.Errorf("ByCategory[%d].F1 = %.4f, want %.4f", cat, cm.F1, want) + } + } + } +} + +func TestComputeModeAgg(t *testing.T) { + // Two samples with different question counts: + // sample-a: 2 questions, F1 = [0.4, 0.6] → avg 0.5 + // sample-b: 8 questions, F1 = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1] → avg 0.1 + // + // Unweighted (PrintComparison bug): (0.5 + 0.1) / 2 = 0.3 + // Weighted (correct): (0.4+0.6 + 0.1*8) / 10 = 1.8 / 10 = 0.18 + results := []EvalResult{ + { + Mode: "test", + SampleID: "sample-a", + QAResults: []QAResult{ + {TokenF1: 0.4, HitRate: 0.5}, + {TokenF1: 0.6, HitRate: 0.7}, + }, + }, + { + Mode: "test", + SampleID: "sample-b", + QAResults: []QAResult{ + {TokenF1: 0.1, HitRate: 0.2}, + {TokenF1: 0.1, HitRate: 0.2}, + {TokenF1: 0.1, HitRate: 0.2}, + {TokenF1: 0.1, HitRate: 0.2}, + {TokenF1: 0.1, HitRate: 0.2}, + {TokenF1: 0.1, HitRate: 0.2}, + {TokenF1: 0.1, HitRate: 0.2}, + {TokenF1: 0.1, HitRate: 0.2}, + }, + }, + } + // Compute per-sample aggregates + for i := range results { + results[i].Agg = aggregateMetrics(results[i].QAResults) + } + + got := computeModeAgg(results) + + // Weighted: (0.4+0.6+0.1*8) / 10 = 1.8/10 = 0.18 + wantF1 := 0.18 + if math.Abs(got.OverallF1-wantF1) > 1e-9 { + t.Errorf("OverallF1 = %.6f, want %.6f (weighted average)", got.OverallF1, wantF1) + } + + // Weighted: (0.5+0.7+0.2*8) / 10 = 2.8/10 = 0.28 + wantRecall := 0.28 + if math.Abs(got.OverallHitRate-wantRecall) > 1e-9 { + t.Errorf("OverallHitRate = %.6f, want %.6f (weighted average)", got.OverallHitRate, wantRecall) + } + + if got.TotalQuestions != 10 { + t.Errorf("TotalQuestions = %d, want 10", got.TotalQuestions) + } +} diff --git a/cmd/membench/ingest.go b/cmd/membench/ingest.go new file mode 100644 index 000000000..70d559c2b --- /dev/null +++ b/cmd/membench/ingest.go @@ -0,0 +1,85 @@ +package main + +import ( + "context" + "fmt" + "log" + + "github.com/sipeed/picoclaw/pkg/seahorse" +) + +// ConvMap stores the mapping from sampleID to seahorse ConversationID. +type ConvMap map[string]int64 + +// SeahorseIngestResult holds the results of ingesting into seahorse. +type SeahorseIngestResult struct { + Engine *seahorse.Engine + ConvMap ConvMap // sampleID → conversationID +} + +// IngestSeahorse loads all LOCOMO samples into a seahorse Engine. +// Returns the engine and a mapping from sampleID to conversationID for scoped retrieval. +func IngestSeahorse(ctx context.Context, samples []LocomoSample, dbPath string) (*SeahorseIngestResult, error) { + noopFn := func(ctx context.Context, prompt string, opts seahorse.CompleteOptions) (string, error) { + return "", nil + } + + engine, err := seahorse.NewEngine(seahorse.Config{ + DBPath: dbPath, + }, noopFn) + if err != nil { + return nil, fmt.Errorf("create seahorse engine: %w", err) + } + + store := engine.GetRetrieval().Store() + convMap := make(ConvMap) + + for si := range samples { + sample := &samples[si] + sessionKey := "locomo-" + sample.SampleID + + // Check if conversation already exists (idempotent) + existing, _ := store.GetConversationBySessionKey(ctx, sessionKey) + if existing != nil { + convMap[sample.SampleID] = existing.ConversationID + log.Printf("Skipping existing sample %s: convID=%d", sample.SampleID, existing.ConversationID) + continue + } + + turns := GetTurns(sample) + + // Convert turns to seahorse messages + msgs := make([]seahorse.Message, 0, len(turns)) + for _, turn := range turns { + content := turn.Speaker + ": " + turn.Text + msgs = append(msgs, seahorse.Message{ + Role: "user", + Content: content, + TokenCount: len(turn.Text) / 4, + }) + } + + // Ingest all turns for this sample + _, err := engine.Ingest(ctx, sessionKey, msgs) + if err != nil { + return nil, fmt.Errorf("ingest sample %s: %w", sample.SampleID, err) + } + + // Get the conversation ID for scoped retrieval + conv, err := store.GetConversationBySessionKey(ctx, sessionKey) + if err != nil { + return nil, fmt.Errorf("get conversation for %s: %w", sample.SampleID, err) + } + if conv == nil { + return nil, fmt.Errorf("conversation not found for %s after ingest", sample.SampleID) + } + convMap[sample.SampleID] = conv.ConversationID + log.Printf("Ingested sample %s: %d turns, convID=%d", sample.SampleID, len(turns), conv.ConversationID) + } + + log.Printf("Seahorse ingestion complete: %d samples, %d conversations", len(samples), len(convMap)) + return &SeahorseIngestResult{ + Engine: engine, + ConvMap: convMap, + }, nil +} diff --git a/cmd/membench/ingest_test.go b/cmd/membench/ingest_test.go new file mode 100644 index 000000000..e8748deed --- /dev/null +++ b/cmd/membench/ingest_test.go @@ -0,0 +1,79 @@ +package main + +import ( + "context" + "encoding/json" + "path/filepath" + "testing" + + "github.com/sipeed/picoclaw/pkg/seahorse" +) + +func TestIngestSeahorseIdempotent(t *testing.T) { + ctx := context.Background() + tmpDir := t.TempDir() + dbPath := filepath.Join(tmpDir, "test.db") + + // Minimal test data + samples := []LocomoSample{ + { + SampleID: "test-1", + Conversation: map[string]json.RawMessage{ + "session_1": json.RawMessage(`[ + {"speaker":"A","dia_id":"D1:1","text":"hello world this is a test message"}, + {"speaker":"B","dia_id":"D1:2","text":"another message for testing purposes"} + ]`), + }, + }, + } + + // First ingestion + result1, err := IngestSeahorse(ctx, samples, dbPath) + if err != nil { + t.Fatalf("first ingest failed: %v", err) + } + convCount1 := len(result1.ConvMap) + result1.Engine.Close() + + // Second ingestion on same DB — should reuse existing data + result2, err := IngestSeahorse(ctx, samples, dbPath) + if err != nil { + t.Fatalf("second ingest failed: %v", err) + } + defer result2.Engine.Close() + + // ConvMap should have same number of entries (no duplicates) + if len(result2.ConvMap) != convCount1 { + t.Errorf("second ingest convMap has %d entries, want %d (same as first)", + len(result2.ConvMap), convCount1) + } + + // Verify conversation IDs are the same (reused, not new ones) + for id, cid1 := range result1.ConvMap { + cid2, ok := result2.ConvMap[id] + if !ok { + t.Errorf("sample %s missing from second ConvMap", id) + continue + } + if cid2 != cid1 { + t.Errorf("sample %s: second ingest got convID %d, want %d (reused)", id, cid2, cid1) + } + } + + // Verify no duplicate messages by counting + store := result2.Engine.GetRetrieval().Store() + for _, convID := range result2.ConvMap { + msgs, err := store.SearchMessages(ctx, seahorse.SearchInput{ + Pattern: "test", + ConversationID: convID, + Limit: 100, + }) + if err != nil { + t.Fatalf("search failed: %v", err) + } + // Should find exactly 1 message containing "test" (the first turn) + if len(msgs) > 2 { + t.Errorf("found %d messages for 'test' in conv %d, expected ≤2 (no duplicates)", len(msgs), convID) + } + } +} diff --git a/cmd/membench/legacy_store.go b/cmd/membench/legacy_store.go new file mode 100644 index 000000000..80cbd2704 --- /dev/null +++ b/cmd/membench/legacy_store.go @@ -0,0 +1,34 @@ +package main + +import ( + "github.com/sipeed/picoclaw/pkg/providers" + "github.com/sipeed/picoclaw/pkg/session" +) + +// LegacyStore wraps session.SessionManager for legacy baseline. +type LegacyStore struct { + sm *session.SessionManager +} + +// NewLegacyStore creates a new in-memory session manager. +func NewLegacyStore() *LegacyStore { + return &LegacyStore{ + sm: session.NewSessionManager(""), + } +} + +// IngestSample loads all turns from a LOCOMO sample into the legacy session store. +func (ls *LegacyStore) IngestSample(sample *LocomoSample) { + sessionKey := "locomo-" + sample.SampleID + turns := GetTurns(sample) + for _, turn := range turns { + content := turn.Speaker + ": " + turn.Text + ls.sm.AddMessage(sessionKey, "user", content) + } +} + +// GetHistory returns all messages for a sample's session. +func (ls *LegacyStore) GetHistory(sampleID string) []providers.Message { + sessionKey := "locomo-" + sampleID + return ls.sm.GetHistory(sessionKey) +} diff --git a/cmd/membench/locomo.go b/cmd/membench/locomo.go new file mode 100644 index 000000000..28ace3680 --- /dev/null +++ b/cmd/membench/locomo.go @@ -0,0 +1,142 @@ +package main + +import ( + "encoding/json" + "fmt" + "log" + "os" + "path/filepath" + "sort" + "strconv" + "strings" +) + +// LocomoSample represents one conversation sample from the LOCOMO dataset. +type LocomoSample struct { + SampleID string `json:"sample_id"` + Conversation map[string]json.RawMessage `json:"conversation"` + QA []LocomoQA `json:"qa"` +} + +// LocomoTurn represents a single turn in a conversation. +type LocomoTurn struct { + Speaker string `json:"speaker"` + DiaID string `json:"dia_id"` + Text string `json:"text"` +} + +// LocomoQA represents a question-answer pair with evidence. +type LocomoQA struct { + Question string `json:"question"` + Answer json.RawMessage `json:"answer"` // can be string or int (category 1-4) + AdversarialAnswer string `json:"adversarial_answer"` // category 5 only + Evidence []string `json:"evidence"` + Category int `json:"category"` // 1=single-hop, 2=multi-hop, 3=open-ended, 5=adversarial +} + +// AnswerString returns the answer as a string, handling both string and int types. +func (qa *LocomoQA) AnswerString() string { + // Prefer answer field (category 1-4) + if len(qa.Answer) > 0 { + var s string + if err := json.Unmarshal(qa.Answer, &s); err == nil { + return s + } + var n json.Number + if err := json.Unmarshal(qa.Answer, &n); err == nil { + return n.String() + } + return strings.Trim(string(qa.Answer), `"`) + } + // Fallback to adversarial_answer (category 5) + return qa.AdversarialAnswer +} + +// LoadDataset reads all JSON files from dataDir and returns parsed samples. +func LoadDataset(dataDir string) ([]LocomoSample, error) { + entries, err := os.ReadDir(dataDir) + if err != nil { + return nil, fmt.Errorf("read data dir %s: %w", dataDir, err) + } + + var samples []LocomoSample + for _, entry := range entries { + if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".json") { + path := filepath.Join(dataDir, entry.Name()) + data, err := os.ReadFile(path) + if err != nil { + return nil, fmt.Errorf("read file %s: %w", path, err) + } + var batch []LocomoSample + if err := json.Unmarshal(data, &batch); err != nil { + return nil, fmt.Errorf("parse file %s: %w", path, err) + } + samples = append(samples, batch...) + } + } + return samples, nil +} + +// GetSessionNames returns sorted session keys (session_1, session_2, ...) from conversation. +func GetSessionNames(conv map[string]json.RawMessage) []string { + var names []string + for k := range conv { + if strings.HasPrefix(k, "session_") && !strings.Contains(k, "_date_time") { + names = append(names, k) + } + } + sort.Slice(names, func(i, j int) bool { + ni := sessionNum(names[i]) + nj := sessionNum(names[j]) + return ni < nj + }) + return names +} + +func sessionNum(key string) int { + // "session_1" → 1, "session_10" → 10 + parts := strings.SplitN(key, "_", 2) + if len(parts) < 2 { + return 0 + } + n, _ := strconv.Atoi(parts[1]) + return n +} + +// GetTurns flattens all sessions' turns in chronological order. +func GetTurns(sample *LocomoSample) []LocomoTurn { + names := GetSessionNames(sample.Conversation) + var all []LocomoTurn + for _, name := range names { + raw, ok := sample.Conversation[name] + if !ok { + continue + } + var turns []LocomoTurn + if err := json.Unmarshal(raw, &turns); err != nil { + log.Printf("WARNING: unmarshal failed for session %q in sample %s: %v", name, sample.SampleID, err) + continue + } + all = append(all, turns...) + } + return all +} + +// GetTurnByDiaID finds a specific turn by dia_id (e.g. "D1:3"). +func GetTurnByDiaID(sample *LocomoSample, diaID string) *LocomoTurn { + turns := GetTurns(sample) + for i := range turns { + if turns[i].DiaID == diaID { + return &turns[i] + } + } + return nil +} + +// GetSpeakers returns the two speaker names from conversation metadata. +func GetSpeakers(conv map[string]json.RawMessage) (string, string) { + var a, b string + json.Unmarshal(conv["speaker_a"], &a) + json.Unmarshal(conv["speaker_b"], &b) + return a, b +} diff --git a/cmd/membench/locomo_test.go b/cmd/membench/locomo_test.go new file mode 100644 index 000000000..2d5170bc9 --- /dev/null +++ b/cmd/membench/locomo_test.go @@ -0,0 +1,67 @@ +package main + +import ( + "encoding/json" + "testing" +) + +func TestAnswerString(t *testing.T) { + tests := []struct { + name string + json string + want string + }{ + { + "string answer", + `{"question":"Q","answer":"Paris","evidence":[],"category":1}`, + "Paris", + }, + { + "int answer", + `{"question":"Q","answer":42,"evidence":[],"category":1}`, + "42", + }, + { + "adversarial answer (category 5)", + `{"question":"Q","evidence":[],"category":5,"adversarial_answer":"self-care is important"}`, + "self-care is important", + }, + { + "both answer and adversarial_answer present", + `{"question":"Q","answer":"normal","evidence":[],"category":5,"adversarial_answer":"adversarial"}`, + "normal", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + var qa LocomoQA + if err := json.Unmarshal([]byte(tt.json), &qa); err != nil { + t.Fatalf("unmarshal: %v", err) + } + got := qa.AnswerString() + if got != tt.want { + t.Errorf("AnswerString() = %q, want %q", got, tt.want) + } + }) + } +} + +func TestGetSessionNames(t *testing.T) { + conv := map[string]json.RawMessage{ + "session_2": {}, + "session_1": {}, + "session_10": {}, + "session_1_date_time": {}, + "speaker_a": {}, + } + names := GetSessionNames(conv) + want := []string{"session_1", "session_2", "session_10"} + if len(names) != len(want) { + t.Fatalf("got %v, want %v", names, want) + } + for i, n := range names { + if n != want[i] { + t.Errorf("names[%d] = %q, want %q", i, n, want[i]) + } + } +} diff --git a/cmd/membench/main.go b/cmd/membench/main.go new file mode 100644 index 000000000..0c5a9387a --- /dev/null +++ b/cmd/membench/main.go @@ -0,0 +1,208 @@ +package main + +import ( + "context" + "encoding/json" + "fmt" + "log" + "os" + "path/filepath" + "strings" + + "github.com/spf13/cobra" + + "github.com/sipeed/picoclaw/pkg/logger" +) + +var ( + flagData string + flagOut string + flagMode string + flagBudget int +) + +func main() { + // Suppress seahorse INFO logs during benchmark + logger.SetLevel(logger.WARN) + + rootCmd := &cobra.Command{ + Use: "membench", + Short: "Memory benchmark tool for picoclaw", + } + + ingestCmd := &cobra.Command{ + Use: "ingest", + Short: "Load LOCOMO data into storage backends", + RunE: runIngest, + } + ingestCmd.Flags().StringVar(&flagData, "data", "", "LOCOMO dataset directory (required)") + ingestCmd.Flags().StringVar(&flagOut, "out", "./bench-out", "output working directory") + ingestCmd.Flags().StringVar(&flagMode, "mode", "all", "modes to ingest: legacy, seahorse, or all") + + evalCmd := &cobra.Command{ + Use: "eval", + Short: "Run QA evaluation against ingested data", + RunE: runEval, + } + evalCmd.Flags().StringVar(&flagData, "data", "", "LOCOMO dataset directory (required)") + evalCmd.Flags().StringVar(&flagOut, "out", "./bench-out", "output working directory") + evalCmd.Flags().StringVar(&flagMode, "mode", "all", "modes to evaluate: legacy, seahorse, or all") + evalCmd.Flags().IntVar(&flagBudget, "budget", 4000, "token budget for retrieval") + + reportCmd := &cobra.Command{ + Use: "report", + Short: "Output comparison results from evaluation", + RunE: runReport, + } + reportCmd.Flags().StringVar(&flagOut, "out", "./bench-out", "output working directory") + + runCmd := &cobra.Command{ + Use: "run", + Short: "Convenience: eval + report (ingestion is done inline)", + RunE: runAll, + } + runCmd.Flags().StringVar(&flagData, "data", "", "LOCOMO dataset directory (required)") + runCmd.Flags().StringVar(&flagOut, "out", "./bench-out", "output working directory") + runCmd.Flags().StringVar(&flagMode, "mode", "all", "modes to run: legacy, seahorse, or all") + runCmd.Flags().IntVar(&flagBudget, "budget", 4000, "token budget for retrieval") + + rootCmd.AddCommand(ingestCmd, evalCmd, reportCmd, runCmd) + + if err := rootCmd.Execute(); err != nil { + os.Exit(1) + } +} + +func modesFromFlag() []string { + switch strings.ToLower(flagMode) { + case "all": + return []string{"legacy", "seahorse"} + default: + return []string{strings.ToLower(flagMode)} + } +} + +func runIngest(cmd *cobra.Command, args []string) error { + if flagData == "" { + return fmt.Errorf("--data is required") + } + modes := modesFromFlag() + if len(modes) == 0 { + return nil + } + + ctx := context.Background() + samples, err := LoadDataset(flagData) + if err != nil { + return fmt.Errorf("load dataset: %w", err) + } + log.Printf("Loaded %d samples from %s", len(samples), flagData) + + for _, mode := range modes { + switch mode { + case "legacy": + legacy := NewLegacyStore() + for i := range samples { + legacy.IngestSample(&samples[i]) + } + log.Printf("legacy: ingested %d samples", len(samples)) + case "seahorse": + dbPath := filepath.Join(flagOut, "seahorse.db") + if err := os.MkdirAll(flagOut, 0o755); err != nil { + return fmt.Errorf("create out dir: %w", err) + } + _, err := IngestSeahorse(ctx, samples, dbPath) + if err != nil { + return fmt.Errorf("ingest seahorse: %w", err) + } + } + } + return nil +} + +func runEval(cmd *cobra.Command, args []string) error { + if flagData == "" { + return fmt.Errorf("--data is required") + } + modes := modesFromFlag() + if len(modes) == 0 { + return nil + } + + ctx := context.Background() + samples, err := LoadDataset(flagData) + if err != nil { + return fmt.Errorf("load dataset: %w", err) + } + log.Printf("Loaded %d samples", len(samples)) + + var allResults []EvalResult + + for _, mode := range modes { + switch mode { + case "legacy": + legacy := NewLegacyStore() + for i := range samples { + legacy.IngestSample(&samples[i]) + } + results := EvalLegacy(ctx, samples, legacy, flagBudget) + allResults = append(allResults, results...) + log.Printf("legacy: evaluated %d samples", len(results)) + case "seahorse": + dbPath := filepath.Join(flagOut, "seahorse.db") + ir, err := IngestSeahorse(ctx, samples, dbPath) + if err != nil { + return fmt.Errorf("ingest seahorse: %w", err) + } + results := EvalSeahorse(ctx, samples, ir, flagBudget) + allResults = append(allResults, results...) + log.Printf("seahorse: evaluated %d samples", len(results)) + } + } + + if err := SaveResults(allResults, flagOut); err != nil { + return fmt.Errorf("save results: %w", err) + } + if err := SaveAggregated(allResults, flagOut); err != nil { + return fmt.Errorf("save aggregated: %w", err) + } + + PrintComparison(allResults, nil) + return nil +} + +func runReport(cmd *cobra.Command, args []string) error { + entries, err := os.ReadDir(flagOut) + if err != nil { + return fmt.Errorf("read out dir: %w", err) + } + + var allResults []EvalResult + for _, entry := range entries { + if !entry.IsDir() && strings.HasPrefix(entry.Name(), "eval_") && strings.HasSuffix(entry.Name(), ".json") { + path := filepath.Join(flagOut, entry.Name()) + var r EvalResult + data, err := os.ReadFile(path) + if err != nil { + log.Printf("WARN: read %s: %v", path, err) + continue + } + if err := json.Unmarshal(data, &r); err != nil { + log.Printf("WARN: parse %s: %v", path, err) + continue + } + allResults = append(allResults, r) + } + } + + if len(allResults) == 0 { + return fmt.Errorf("no eval results found in %s", flagOut) + } + + PrintComparison(allResults, nil) + return nil +} + +func runAll(cmd *cobra.Command, args []string) error { + return runEval(cmd, args) +} diff --git a/cmd/membench/metrics.go b/cmd/membench/metrics.go new file mode 100644 index 000000000..7e3db2dde --- /dev/null +++ b/cmd/membench/metrics.go @@ -0,0 +1,227 @@ +package main + +import ( + "fmt" + "log" + "regexp" + "strconv" + "strings" + "unicode" +) + +// diaIDRe matches valid dia_id patterns like "D1:3", "D30:5". +var diaIDRe = regexp.MustCompile(`^D(\d+):(\d+)$`) + +// SplitEvidenceIDs splits an evidence string that may contain multiple +// semicolon-separated or space-separated dia_ids. Only returns valid IDs. +// Example: "D8:6; D9:17" → ["D8:6", "D9:17"] +// Example: "D9:1 D4:4 D4:6" → ["D9:1", "D4:4", "D4:6"] +func SplitEvidenceIDs(evidence string) []string { + if evidence == "" { + return nil + } + // Split on semicolons first, then spaces + parts := strings.Split(evidence, ";") + var ids []string + for _, part := range parts { + for _, token := range strings.Fields(strings.TrimSpace(part)) { + token = strings.TrimSpace(token) + if diaIDRe.MatchString(token) { + ids = append(ids, NormalizeDiaID(token)) + } + } + } + if len(ids) == 0 { + return nil + } + return ids +} + +// NormalizeDiaID strips leading zeros from the number parts of a dia_id. +// "D30:05" → "D30:5", "D10:003" → "D10:3" +func NormalizeDiaID(id string) string { + m := diaIDRe.FindStringSubmatch(id) + if m == nil { + return id + } + session, _ := strconv.Atoi(m[1]) + turn, _ := strconv.Atoi(m[2]) + return fmt.Sprintf("D%d:%d", session, turn) +} + +// stopwords is a fixed English stopword list for deterministic keyword extraction. +var stopwords = map[string]struct{}{ + "a": {}, "an": {}, "the": {}, + "is": {}, "are": {}, "was": {}, "were": {}, + "did": {}, "does": {}, "do": {}, + "when": {}, "where": {}, "what": {}, "who": {}, + "how": {}, "why": {}, + "to": {}, "of": {}, "in": {}, "on": {}, "at": {}, + "for": {}, "and": {}, "or": {}, "but": {}, "not": {}, + "it": {}, "this": {}, "that": {}, "with": {}, + "from": {}, "by": {}, "as": {}, + "if": {}, "then": {}, "than": {}, "so": {}, + "no": {}, "yes": {}, + "all": {}, "any": {}, "each": {}, "every": {}, + "some": {}, "such": {}, + "about": {}, "into": {}, "over": {}, + "after": {}, "before": {}, "between": {}, + "through": {}, "during": {}, "until": {}, + "would": {}, "could": {}, "should": {}, + "may": {}, "might": {}, "can": {}, + "will": {}, "shall": {}, "must": {}, + "have": {}, "has": {}, "had": {}, + "been": {}, "being": {}, "be": {}, + "go": {}, "went": {}, "gone": {}, + "i": {}, "you": {}, "me": {}, "my": {}, "your": {}, + "we": {}, "they": {}, "them": {}, "our": {}, + "its": {}, "their": {}, "he": {}, "she": {}, + "his": {}, "her": {}, +} + +// ExtractKeywords removes stopwords and punctuation, returns individual keywords. +// Deterministic: uses fixed stopword list, no LLM. +func ExtractKeywords(question string) []string { + // Lowercase and split on whitespace/punctuation + lower := strings.ToLower(question) + words := strings.FieldsFunc(lower, func(r rune) bool { + return !unicode.IsLetter(r) && !unicode.IsDigit(r) + }) + + var keywords []string + for _, w := range words { + if w == "" || len(w) < 2 { + continue + } + if _, ok := stopwords[w]; ok { + continue + } + keywords = append(keywords, w) + if len(keywords) >= 6 { + break + } + } + return keywords +} + +// TokenOverlapF1 computes token-level F1 between prediction and reference. +// Both strings are lowercased and split on whitespace. +// NOTE: This metric underestimates quality for multi-hop (cat 2) and +// open-ended (cat 3) questions where the gold answer uses different phrasing +// than the source text. LLM-Judge scoring is a v2 follow-up. +func TokenOverlapF1(prediction, reference string) float64 { + predTokens := tokenize(prediction) + refTokens := tokenize(reference) + + if len(predTokens) == 0 && len(refTokens) == 0 { + return 1.0 + } + if len(predTokens) == 0 || len(refTokens) == 0 { + return 0.0 + } + + // Count matches + refCount := map[string]int{} + for _, t := range refTokens { + refCount[t]++ + } + + predCount := map[string]int{} + for _, t := range predTokens { + predCount[t]++ + } + + var matches float64 + for token, pc := range predCount { + if rc, ok := refCount[token]; ok { + matches += float64(min(pc, rc)) + } + } + + precision := matches / float64(len(predTokens)) + recall := matches / float64(len(refTokens)) + + if precision+recall == 0 { + return 0.0 + } + return 2 * precision * recall / (precision + recall) +} + +func tokenize(s string) []string { + lower := strings.ToLower(s) + return strings.Fields(lower) +} + +// RecallHitRate computes fraction of evidence IDs found in retrieved content. +// For each evidence dia_id, looks up the turn text and checks substring match. +// Logs a warning for turns with text < 20 chars (higher false-positive risk). +func RecallHitRate(evidenceIDs []string, sample *LocomoSample, retrievedContent string) float64 { + if len(evidenceIDs) == 0 { + return 1.0 // no evidence required = perfect + } + + // Expand any multi-ID evidence entries (e.g. "D8:6; D9:17" or "D9:1 D4:4") + var expanded []string + for _, id := range evidenceIDs { + split := SplitEvidenceIDs(id) + if split != nil { + expanded = append(expanded, split...) + } + } + if len(expanded) == 0 { + log.Printf("WARNING: no valid dia_ids after expanding evidence %v", evidenceIDs) + return float64(0) / float64(len(evidenceIDs)) + } + + // Build turn index once (avoids re-parsing JSON per ID) + turns := GetTurns(sample) + turnMap := make(map[string]*LocomoTurn, len(turns)) + for i := range turns { + turnMap[turns[i].DiaID] = &turns[i] + } + + lowerRetrieved := strings.ToLower(retrievedContent) + found := 0 + resolvable := 0 + for _, diaID := range expanded { + turn, ok := turnMap[diaID] + if !ok { + log.Printf("WARNING: dia_id %q not found in sample %s", diaID, sample.SampleID) + continue + } + resolvable++ + if len(turn.Text) < 20 { + log.Printf("WARNING: short turn text (%d chars) for dia_id %s: %q", + len(turn.Text), diaID, turn.Text) + } + if strings.Contains(lowerRetrieved, strings.ToLower(turn.Text)) { + found++ + } + } + if resolvable == 0 { + return 0.0 // no resolvable evidence = can't evaluate + } + return float64(found) / float64(resolvable) +} + +// BudgetTruncate truncates messages to fit within a token budget. +// Returns the truncated messages and total token count. +func BudgetTruncate(messages []string, budgetTokens int) ([]string, int) { + var result []string + total := 0 + // Walk from the front (best first) and keep until budget exhausted. + for i := 0; i < len(messages); i++ { + tokens := len(messages[i]) / 4 + if total+tokens > budgetTokens && len(result) > 0 { + break + } + result = append(result, messages[i]) + total += tokens + } + return result, total +} + +// StringListToContent joins a list of strings into a single content string. +func StringListToContent(parts []string) string { + return strings.Join(parts, "\n") +} diff --git a/cmd/membench/metrics_test.go b/cmd/membench/metrics_test.go new file mode 100644 index 000000000..99e4ad6d4 --- /dev/null +++ b/cmd/membench/metrics_test.go @@ -0,0 +1,239 @@ +package main + +import ( + "encoding/json" + "math" + "testing" +) + +func TestSplitEvidenceIDs(t *testing.T) { + tests := []struct { + input string + want []string + }{ + {"D1:3", []string{"D1:3"}}, + {"D8:6; D9:17", []string{"D8:6", "D9:17"}}, + {"D9:1 D4:4 D4:6", []string{"D9:1", "D4:4", "D4:6"}}, + {"D22:1 D22:2 D9:10 D9:11", []string{"D22:1", "D22:2", "D9:10", "D9:11"}}, + {"D21:18 D21:22 D11:15 D11:19", []string{"D21:18", "D21:22", "D11:15", "D11:19"}}, + {"D30:05", []string{"D30:5"}}, + {"D", nil}, + {"D:", nil}, + {"", nil}, + } + for _, tt := range tests { + t.Run(tt.input, func(t *testing.T) { + got := SplitEvidenceIDs(tt.input) + if len(got) != len(tt.want) { + t.Fatalf("SplitEvidenceIDs(%q) = %v, want %v", tt.input, got, tt.want) + } + for i := range got { + if got[i] != tt.want[i] { + t.Errorf("[%d] = %q, want %q", i, got[i], tt.want[i]) + } + } + }) + } +} + +func TestNormalizeDiaID(t *testing.T) { + tests := []struct { + input string + want string + }{ + {"D1:3", "D1:3"}, + {"D30:05", "D30:5"}, + {"D10:003", "D10:3"}, + {"D1:0", "D1:0"}, + } + for _, tt := range tests { + got := NormalizeDiaID(tt.input) + if got != tt.want { + t.Errorf("NormalizeDiaID(%q) = %q, want %q", tt.input, got, tt.want) + } + } +} + +func TestTokenOverlapF1(t *testing.T) { + tests := []struct { + name string + prediction string + reference string + want float64 + }{ + {"exact match", "hello world", "hello world", 1.0}, + {"no overlap", "foo bar", "baz qux", 0.0}, + {"empty both", "", "", 1.0}, + {"empty prediction", "", "hello", 0.0}, + {"empty reference", "hello", "", 0.0}, + {"partial overlap", "the cat sat on the mat", "the cat on the floor", 8.0 / 11.0}, + {"case insensitive", "Hello World", "hello world", 1.0}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := TokenOverlapF1(tt.prediction, tt.reference) + if math.Abs(got-tt.want) > 1e-9 { + t.Errorf("TokenOverlapF1(%q, %q) = %.4f, want %.4f", + tt.prediction, tt.reference, got, tt.want) + } + }) + } +} + +func TestBudgetTruncate(t *testing.T) { + t.Run("within budget returns all", func(t *testing.T) { + msgs := []string{"short", "message", "here"} + result, total := BudgetTruncate(msgs, 1000) + if len(result) != 3 { + t.Errorf("expected 3 messages, got %d", len(result)) + } + if total == 0 { + t.Error("expected non-zero token count") + } + }) + + t.Run("over budget keeps best first", func(t *testing.T) { + msgs := []string{ + "best message that is quite long and takes up tokens", + "good message also fairly long content", + "worst short", + } + result, _ := BudgetTruncate(msgs, 5) // very small budget + if len(result) == 0 { + t.Fatal("expected at least one message") + } + // Best-ranked (first) should be kept + if result[0] != "best message that is quite long and takes up tokens" { + t.Errorf("expected best message kept first, got %q", result[0]) + } + }) + + t.Run("over budget keeps best ranked first", func(t *testing.T) { + // Messages are sorted by bm25 rank ascending (best/most-negative first). + // When budget is insufficient, BudgetTruncate must keep the front + // (best-ranked) messages, not the tail (worst-ranked). + msgs := []string{ + "best ranked message with some content here", + "second best message also has content", + "third message here too", + "worst ranked short", + } + // Budget only fits ~1 message (~10 tokens per message, budget=12) + result, _ := BudgetTruncate(msgs, 12) + if len(result) == 0 { + t.Fatal("expected at least one message") + } + if result[0] != "best ranked message with some content here" { + t.Errorf("expected best-ranked (first) message kept, got %q", result[0]) + } + // Worst-ranked (last) must NOT appear + for _, m := range result { + if m == "worst ranked short" { + t.Error("worst-ranked message should have been truncated") + } + } + }) + + t.Run("preserves original order", func(t *testing.T) { + msgs := []string{"alpha", "beta", "gamma"} + result, _ := BudgetTruncate(msgs, 100) + for i, got := range result { + if got != msgs[i] { + t.Errorf("result[%d] = %q, want %q", i, got, msgs[i]) + } + } + }) + + t.Run("empty input", func(t *testing.T) { + result, total := BudgetTruncate(nil, 100) + if len(result) != 0 { + t.Errorf("expected 0 messages, got %d", len(result)) + } + if total != 0 { + t.Errorf("expected 0 tokens, got %d", total) + } + }) +} + +func TestRecallHitRate(t *testing.T) { + // Build a sample with known turns + sample := &LocomoSample{ + SampleID: "test-sample", + Conversation: map[string]json.RawMessage{ + "session_1": json.RawMessage(`[ + {"speaker":"A","dia_id":"D1:1","text":"hello world this is a test message with enough length"}, + {"speaker":"B","dia_id":"D1:2","text":"another message for testing recall computation purposes here"}, + {"speaker":"A","dia_id":"D1:3","text":"third turn with some more content to test"} + ]`), + }, + } + + t.Run("all evidence found", func(t *testing.T) { + retrieved := "hello world this is a test message with enough length another message for testing recall computation purposes here" + got := RecallHitRate([]string{"D1:1", "D1:2"}, sample, retrieved) + if math.Abs(got-1.0) > 1e-9 { + t.Errorf("RecallHitRate all found = %.4f, want 1.0", got) + } + }) + + t.Run("partial evidence found", func(t *testing.T) { + retrieved := "hello world this is a test message with enough length" + got := RecallHitRate([]string{"D1:1", "D1:2"}, sample, retrieved) + if math.Abs(got-0.5) > 1e-9 { + t.Errorf("RecallHitRate partial = %.4f, want 0.5", got) + } + }) + + t.Run("no evidence required", func(t *testing.T) { + got := RecallHitRate(nil, sample, "anything") + if got != 1.0 { + t.Errorf("RecallHitRate no evidence = %.4f, want 1.0", got) + } + }) + + t.Run("missing turn excluded from denominator", func(t *testing.T) { + // D1:1 is found, D99:1 does not exist in sample + // Should only count resolvable turns in denominator + retrieved := "hello world this is a test message with enough length" + got := RecallHitRate([]string{"D1:1", "D99:1"}, sample, retrieved) + if math.Abs(got-1.0) > 1e-9 { + t.Errorf("RecallHitRate missing turn = %.4f, want 1.0 (unresolvable excluded)", got) + } + }) +} + +func TestExtractKeywords(t *testing.T) { + tests := []struct { + name string + input string + want []string + }{ + {"simple", "What is the capital of France", []string{"capital", "france"}}, + { + "stops removed", + "Who is the president of the United States", + []string{"president", "united", "states"}, + }, + { + "max 6 keywords", + "one two three four five six seven eight nine ten", + []string{"one", "two", "three", "four", "five", "six"}, + }, + {"short words filtered", "I am a go to the store", []string{"am", "store"}}, + {"empty", "", nil}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := ExtractKeywords(tt.input) + if len(got) != len(tt.want) { + t.Fatalf("ExtractKeywords(%q) = %v (len %d), want %v (len %d)", + tt.input, got, len(got), tt.want, len(tt.want)) + } + for i := range got { + if got[i] != tt.want[i] { + t.Errorf("[%d] = %q, want %q", i, got[i], tt.want[i]) + } + } + }) + } +} diff --git a/go.mod b/go.mod index 008303a2b..7044e29e8 100644 --- a/go.mod +++ b/go.mod @@ -84,6 +84,7 @@ require ( github.com/petermattis/goid v0.0.0-20260226131333-17d1149c6ac6 // indirect github.com/pion/randutil v0.1.0 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/reiver/go-porterstemmer v1.0.1 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect github.com/rivo/uniseg v0.4.7 // indirect github.com/segmentio/asm v1.1.3 // indirect diff --git a/go.sum b/go.sum index d12de0f47..67ccd2b12 100644 --- a/go.sum +++ b/go.sum @@ -214,6 +214,8 @@ github.com/pion/webrtc/v3 v3.3.6/go.mod h1:zyN7th4mZpV27eXybfR/cnUf3J2DRy8zw/mdj github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/reiver/go-porterstemmer v1.0.1 h1:WyERBkASXgoXrTwq/IQ6wyNj/YG7j/ZURvTuMCoud5w= +github.com/reiver/go-porterstemmer v1.0.1/go.mod h1:Z8uL/f/7UEwaeAJNwx1sO8kbqXiEuQieNuD735hLrSU= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/rivo/tview v0.42.0 h1:b/ftp+RxtDsHSaynXTbJb+/n/BxDEi+W3UfF5jILK6c= From 9ec27835cf793071ec32ba262db0f85ee85bbc17 Mon Sep 17 00:00:00 2001 From: Guoguo <16666742+imguoguo@users.noreply.github.com> Date: Tue, 7 Apr 2026 09:34:54 +0800 Subject: [PATCH 021/174] fix(docker): add -console flag and open network for launcher (#2314) - Add -console to Dockerfile CMD so launcher outputs logs to stdout, making docker logs work as expected - Remove 127.0.0.1 bind from ports to allow public network access - Add commented PICOCLAW_LAUNCHER_TOKEN env var example Co-authored-by: Claude Opus 4.6 (1M context) --- docker/Dockerfile.goreleaser.launcher | 2 +- docker/docker-compose.yml | 7 +++++-- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/docker/Dockerfile.goreleaser.launcher b/docker/Dockerfile.goreleaser.launcher index 5d65576f7..0a20a90b3 100644 --- a/docker/Dockerfile.goreleaser.launcher +++ b/docker/Dockerfile.goreleaser.launcher @@ -9,4 +9,4 @@ COPY $TARGETPLATFORM/picoclaw-launcher /usr/local/bin/picoclaw-launcher COPY $TARGETPLATFORM/picoclaw-launcher-tui /usr/local/bin/picoclaw-launcher-tui ENTRYPOINT ["picoclaw-launcher"] -CMD ["-public", "-no-browser"] +CMD ["-console", "-public", "-no-browser"] diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml index 0bf46a2ae..7c940621f 100644 --- a/docker/docker-compose.yml +++ b/docker/docker-compose.yml @@ -45,8 +45,11 @@ services: - launcher environment: - PICOCLAW_GATEWAY_HOST=0.0.0.0 + # Set a fixed dashboard token instead of a random one each restart. + # If not set, a random token is generated and printed to the console on startup. + #- PICOCLAW_LAUNCHER_TOKEN=your-secret-token-here ports: - - "127.0.0.1:18800:18800" - - "127.0.0.1:18790:18790" + - "18800:18800" + - "18790:18790" volumes: - ./data:/root/.picoclaw From 29277d4b3b90b96f406de44b059800a980cc7344 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 7 Apr 2026 09:56:46 +0800 Subject: [PATCH 022/174] build(deps): bump modernc.org/sqlite from 1.47.0 to 1.48.0 (#2289) Bumps [modernc.org/sqlite](https://gitlab.com/cznic/sqlite) from 1.47.0 to 1.48.0. - [Changelog](https://gitlab.com/cznic/sqlite/blob/master/CHANGELOG.md) - [Commits](https://gitlab.com/cznic/sqlite/compare/v1.47.0...v1.48.0) --- updated-dependencies: - dependency-name: modernc.org/sqlite dependency-version: 1.48.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- go.mod | 2 +- go.sum | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/go.mod b/go.mod index 7044e29e8..b4e38e8f0 100644 --- a/go.mod +++ b/go.mod @@ -45,7 +45,7 @@ require ( google.golang.org/protobuf v1.36.11 gopkg.in/yaml.v3 v3.0.1 maunium.net/go/mautrix v0.26.4 - modernc.org/sqlite v1.47.0 + modernc.org/sqlite v1.48.0 rsc.io/qr v0.2.0 ) diff --git a/go.sum b/go.sum index 67ccd2b12..1fcf5da7f 100644 --- a/go.sum +++ b/go.sum @@ -458,8 +458,8 @@ modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8= modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns= modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w= modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE= -modernc.org/sqlite v1.47.0 h1:R1XyaNpoW4Et9yly+I2EeX7pBza/w+pmYee/0HJDyKk= -modernc.org/sqlite v1.47.0/go.mod h1:hWjRO6Tj/5Ik8ieqxQybiEOUXy0NJFNp2tpvVpKlvig= +modernc.org/sqlite v1.48.0 h1:ElZyLop3Q2mHYk5IFPPXADejZrlHu7APbpB0sF78bq4= +modernc.org/sqlite v1.48.0/go.mod h1:hWjRO6Tj/5Ik8ieqxQybiEOUXy0NJFNp2tpvVpKlvig= modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0= modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= From c3e7396a3da093692eb4fe6c431eff7603a5c2a4 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 7 Apr 2026 09:58:20 +0800 Subject: [PATCH 023/174] build(deps): bump github.com/pion/rtp from 1.8.7 to 1.10.1 (#2290) Bumps [github.com/pion/rtp](https://github.com/pion/rtp) from 1.8.7 to 1.10.1. - [Release notes](https://github.com/pion/rtp/releases) - [Commits](https://github.com/pion/rtp/compare/v1.8.7...v1.10.1) --- updated-dependencies: - dependency-name: github.com/pion/rtp dependency-version: 1.10.1 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- go.mod | 2 +- go.sum | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/go.mod b/go.mod index b4e38e8f0..6daa9e7cf 100644 --- a/go.mod +++ b/go.mod @@ -29,7 +29,7 @@ require ( github.com/mymmrac/telego v1.7.0 github.com/open-dingtalk/dingtalk-stream-sdk-go v0.9.1 github.com/openai/openai-go/v3 v3.22.0 - github.com/pion/rtp v1.8.7 + github.com/pion/rtp v1.10.1 github.com/pion/webrtc/v3 v3.3.6 github.com/rivo/tview v0.42.0 github.com/rs/zerolog v1.35.0 diff --git a/go.sum b/go.sum index 1fcf5da7f..03526f378 100644 --- a/go.sum +++ b/go.sum @@ -207,8 +207,8 @@ github.com/petermattis/goid v0.0.0-20260226131333-17d1149c6ac6 h1:rh2lKw/P/EqHa7 github.com/petermattis/goid v0.0.0-20260226131333-17d1149c6ac6/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4= github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA= github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8= -github.com/pion/rtp v1.8.7 h1:qslKkG8qxvQ7hqaxkmL7Pl0XcUm+/Er7nMnu6Vq+ZxM= -github.com/pion/rtp v1.8.7/go.mod h1:pBGHaFt/yW7bf1jjWAoUjpSNoDnw98KTMg+jWWvziqU= +github.com/pion/rtp v1.10.1 h1:xP1prZcCTUuhO2c83XtxyOHJteISg6o8iPsE2acaMtA= +github.com/pion/rtp v1.10.1/go.mod h1:rF5nS1GqbR7H/TCpKwylzeq6yDM+MM6k+On5EgeThEM= github.com/pion/webrtc/v3 v3.3.6 h1:7XAh4RPtlY1Vul6/GmZrv7z+NnxKA6If0KStXBI2ZLE= github.com/pion/webrtc/v3 v3.3.6/go.mod h1:zyN7th4mZpV27eXybfR/cnUf3J2DRy8zw/mdjD9JTNM= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= From 661ce5e311b34c9c4a3f022d6462a2609aae80d4 Mon Sep 17 00:00:00 2001 From: wenjie Date: Tue, 7 Apr 2026 11:49:35 +0800 Subject: [PATCH 024/174] fix(build): gate seahorse context manager on unsupported platforms (#2384) - add build tags to exclude context_seahorse.go on mipsle and netbsd - add context_seahorse_unsupported.go to keep registration and return a clear runtime error - remove unused indirect dependency github.com/reiver/go-porterstemmer from go.mod and go.sum --- go.mod | 1 - go.sum | 2 -- pkg/agent/context_seahorse.go | 2 ++ pkg/agent/context_seahorse_unsupported.go | 20 ++++++++++++++++++++ 4 files changed, 22 insertions(+), 3 deletions(-) create mode 100644 pkg/agent/context_seahorse_unsupported.go diff --git a/go.mod b/go.mod index 6daa9e7cf..cc5385f7d 100644 --- a/go.mod +++ b/go.mod @@ -84,7 +84,6 @@ require ( github.com/petermattis/goid v0.0.0-20260226131333-17d1149c6ac6 // indirect github.com/pion/randutil v0.1.0 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/reiver/go-porterstemmer v1.0.1 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect github.com/rivo/uniseg v0.4.7 // indirect github.com/segmentio/asm v1.1.3 // indirect diff --git a/go.sum b/go.sum index 03526f378..275184b8a 100644 --- a/go.sum +++ b/go.sum @@ -214,8 +214,6 @@ github.com/pion/webrtc/v3 v3.3.6/go.mod h1:zyN7th4mZpV27eXybfR/cnUf3J2DRy8zw/mdj github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/reiver/go-porterstemmer v1.0.1 h1:WyERBkASXgoXrTwq/IQ6wyNj/YG7j/ZURvTuMCoud5w= -github.com/reiver/go-porterstemmer v1.0.1/go.mod h1:Z8uL/f/7UEwaeAJNwx1sO8kbqXiEuQieNuD735hLrSU= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/rivo/tview v0.42.0 h1:b/ftp+RxtDsHSaynXTbJb+/n/BxDEi+W3UfF5jILK6c= diff --git a/pkg/agent/context_seahorse.go b/pkg/agent/context_seahorse.go index 104a84a78..a2e09095a 100644 --- a/pkg/agent/context_seahorse.go +++ b/pkg/agent/context_seahorse.go @@ -1,3 +1,5 @@ +//go:build !mipsle && !netbsd + package agent import ( diff --git a/pkg/agent/context_seahorse_unsupported.go b/pkg/agent/context_seahorse_unsupported.go new file mode 100644 index 000000000..882a973b9 --- /dev/null +++ b/pkg/agent/context_seahorse_unsupported.go @@ -0,0 +1,20 @@ +//go:build mipsle || netbsd + +package agent + +import ( + "encoding/json" + "fmt" +) + +// newSeahorseContextManager is unavailable on platforms where modernc sqlite/libc +// currently has no stable build path for this project. +func newSeahorseContextManager(_ json.RawMessage, _ *AgentLoop) (ContextManager, error) { + return nil, fmt.Errorf("seahorse context manager is unavailable on this platform") +} + +func init() { + if err := RegisterContextManager("seahorse", newSeahorseContextManager); err != nil { + panic(fmt.Sprintf("register seahorse context manager: %v", err)) + } +} From f0e6b7aa37984faa768c61e016fcab2aca5aed6f Mon Sep 17 00:00:00 2001 From: Liu Yuan Date: Tue, 7 Apr 2026 12:32:28 +0800 Subject: [PATCH 025/174] fix(seahorse): correct bm25 rank semantics in comments (#2360) SQLite FTS5 bm25() returns negative values where numerically smaller (more negative) indicates a better match. The official docs state: "The better the match, the numerically smaller the value returned." Two comments incorrectly stated "closer to 0 = better match" and "lower = better match". Updated all rank descriptions to use the unambiguous "more negative = higher relevance" phrasing. This matters because these comments are used as tool prompt hints for LLM agents, and incorrect semantics could lead to wrong ranking decisions. --- pkg/seahorse/short_retrieval.go | 6 +++--- pkg/seahorse/tool_grep.go | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/pkg/seahorse/short_retrieval.go b/pkg/seahorse/short_retrieval.go index f7d6bf691..3e94eec14 100644 --- a/pkg/seahorse/short_retrieval.go +++ b/pkg/seahorse/short_retrieval.go @@ -68,8 +68,8 @@ type GrepSummaryResult struct { Depth int `json:"depth"` Kind SummaryKind `json:"kind"` ConversationID int64 `json:"conversationId"` - // Rank is the bm25 relevance score (negative value, closer to 0 = better match). - // Examples: -0.5 = excellent match, -2.0 = good match, -10.0 = partial match. + // Rank is the bm25 relevance score (negative value, lower = better match). + // Examples: -5.0 = excellent match, -2.0 = good match, -0.5 = partial match. Rank float64 `json:"rank,omitempty"` } @@ -79,7 +79,7 @@ type GrepMessageResult struct { Snippet string `json:"snippet"` Role string `json:"role"` ConversationID int64 `json:"conversationId"` - Rank float64 `json:"rank,omitempty"` // Relevance score (lower = better match) + Rank float64 `json:"rank,omitempty"` // Relevance score (more negative = better match) } // ExpandMessagesResult contains expanded messages. diff --git a/pkg/seahorse/tool_grep.go b/pkg/seahorse/tool_grep.go index 6502fc5c3..9671d2a7f 100644 --- a/pkg/seahorse/tool_grep.go +++ b/pkg/seahorse/tool_grep.go @@ -56,8 +56,8 @@ Returns: "hint": "No matches. Try: %keyword% for fuzzy search" } -Rank field (FTS5 mode only): bm25 relevance score, negative value where closer to 0 = better match. -Examples: -0.5=excellent, -2=good, -5=partial, -10=weak. LIKE mode (%pattern%) has no rank. +Rank field (FTS5 mode only): bm25 relevance score, negative value where more negative = higher relevance. +Examples: -5=excellent, -2=good, -0.5=partial. LIKE mode (%pattern%) has no rank. Examples: {"pattern": "authentication"} From 84edc462d6df745aec7f980f9c6d3962a66cae34 Mon Sep 17 00:00:00 2001 From: BeaconCat <111232138+BeaconCat@users.noreply.github.com> Date: Tue, 7 Apr 2026 14:09:11 +0800 Subject: [PATCH 026/174] assets: update WeChat QR code image (#2385) Co-authored-by: BeaconCat Co-authored-by: Claude Opus 4.6 --- assets/wechat.png | Bin 373987 -> 370819 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/assets/wechat.png b/assets/wechat.png index 07a05dd91d0bbcd0b380df27591deb9e20d45149..66ffa99e99f5db2ef85b34e6739a1faa7cbff3ff 100644 GIT binary patch literal 370819 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%0AlKJV|h^-wSt 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

-&qkSgfg~5bk-aGw4WiT$4!O(*W3zt8H_Qpn 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 literal 373987 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 z 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

ZP+Jkvkd2AZpr7=oW>cPyP%jsVfpB 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 z zXj$yJE6;jvtZ3I4E&S!dx#-~V?I|D3XG!HFfrdyd@0~F#s{AhU^rIs_fwKpjE<&wEMxl9&DDOSh~94KWAETf1LRIb!NUR#e_n#lzsVWV zXiL~o0}U>qf_h`CH5=u!d*;!)}pap--v4zUf?EDlStV;dxOsX z+T0`{M`tG|4yXHa9PVNEx!Ptyu*AJhhbja96FaWRAcYKwd%viIjnK^1&ggX^YPB$w zGaot9cS$M<*5L${lLz?-W88f43Ghq)01UkFbA(@U9?sIuXAF^l_canO3`|12#?KR1 zP!ik31FtBKc_QMdeWBp@KOn0#TL1p3LP5v;5l>?J>zuML)w2;{^+5RIjY!{Dy>jJB%oXRj4Ti^_Cs)6NB)Nr`3x6Fk?wJrk<4NLA>3Qh>hp6a=x&Zhn zpFhMNQvou+)2`Er-tHD1#K?UChZ!}wFJYcuZ1{V(Kim3WemagzL|2{j**e6pG&M!f+*!zm(K>^X z9AD5D@JY2CRFl26$Bh5q3f6&Yq-K7i;Ot2V_Nv}N3Js|tN{hHVeVR;4^)LU9GHniXGBPMNXVROPdxpATg`$W0eSsQ71_O6hWr$}K%Zc4 zNmEDT4q(#u;C3~8uHLtBPqcC*sVR4K^GvuD>E=HpdnNgd>!XCe{IW}U0Da^5w!fSn zP5{2Hrt2VS6-qxOW*u5Y5<`16?I+oN+qWx}`)ZXFWPV_kco$ zi4P%;XAYW_jhqoa{vfd$@+2e;us=MnSyUBW)8Oy#4~^`U)RCFJcm1*=2lwBJo7gTI%To2u$*zp2$=A^B1~#7X|A>!(0zJw zwPY4`vlhPFfps6eQAyG!;P@FL%*YOt`LbEfQoZ~BusLuQY35cOdPs8DT<>(X;GU~YMtAU@73NNnORqtD%Qf6(4*UW`P5aw6i6AJsr_RP@|S+{j# zi@HvVpjOxV0`U6}+jeVzp_e|zJhS485*2}QB*8B-c^Srj3*1i1mHZ)|tt737asc1- zD0S|(vjK`C2Oo;9EMhwTw>Kwf!+!-&U->>Jf|_vc zI!GlT@jY;Y-SP08nL?M@MC@S$(QKE246^$-1SRLYsacL~{qlIOnfr3-CVN1v-P@U_ zrY86**6Ga!*cvB!W`0~aVdA@e>U`r9lh1f~nzwY|Mfew&87f_e4 z0OtO(du~%wB3pPSQ4uff zmA>_o!u7#)k~h}Za{KQsSd8z0%b+DQ|u4YO8JvTZ{;*L2DATw-9scut>8jf@YiSe zA2|;?1itx%vn_vMV(Dp3(tyryhmsxbMwf~QOKJN~g&b$jp1mcJ*fRqRa+yB;WUtWU znvCwPt-H@Q1m7dUR4PM%kDqwJ7{fWf?B&}zsXBMIF$%3JmD|)fl_U`*wKnvr7FKrf zm_zk0c4zTDuJZLAiTvti1l$qA#OIS~zpda(oioP63%l2;aMb+zvxRK`n9fz?OB_$> znY8at^Vvm3%3!ZDxu?(AJ#g$EghRLopmqXgX+t4cFzfh>$koGA-W*+W2>%bT%FGo! zm%UC%;7#d);O)gOnZy!kw>wseqRw*5u<>uqE6j8Ori%YJ>jlX&7k_*u0t=_Ts!p=d z;DkhnGBjrBP4wM$dgw=C{8#jW4&wl%JHQBg%{KePhe8qTdoyzF4%5L8rMmgMP0e0i zDlwe2chambr(2SUNW>M4Tu>;Pc$h+fE_GWvSXogflb;&L=+X40&apa2!n!m_Q65=oW(>(aNv8>0FSq_7e&Eb^F`f9D5W5 zgbS^ME5a?KOrx%=m3Jf<=+VA(S&NDnbv@@`@hTd0jxw{duXL7C@g$i>@!(*AJ`rOD zL4={u_oXwcsE^<3`MV+G25W^CPjs0CL!6wCq^^KD01xcsANPgO1BE@G(Odm&iZ46Q zsr6Lgkm>{-Vm4L*PdL3ljx6=CIEfvFFzx)1gDTK=m%%=OH zfCg!RyQ+fhQfW1xH0I_c|H5=OhdX~67UhPGKX>W8aQm+c3uS%TE)^JB4Qn(8T4Du>Tz*$F8Oeb+vi`9FqFd+Oyr0eyqV zsF{Ks!RXmK94c8m-nSh3v55R>Yin2;Ldni=b0IM1Foo{-2Q{}r?|_NMkYg5lkQ4c5 zOqI1ccOFbqyC~r}U_C$|rE&vS6Z+{VZMzlBsB*=l*<&UV4ifpN#NX87~(cl%{R7a%& zx;>T`(lRNG-)D|#G+@8|g}T>RkuW{IrWrFTGgrKGr@ESUVrd;EIm|`yO<|loDzg#P zEqNDJi_g|4LPjLIe7d)yf9?#?5*}J~WBpv%-5|EG;w|tVVoeh?zD0c;2?nekITtO6 zB-6msu8QwgDW@R;B%0SPnYJe#vT4Pc_1MnpX#7fh9+Te95iYBOq1nf`-;fm+-%K-E zXcQAa-)Ezmpnbasrcn|?s7sTonfvH>W?kK7#R(G8~!{8JYuXK#L zE7PWe7}(?YN3@Io5)RBp9r+1Ux;sR>kfU#xu%q5HHv49jVPck$5I&9Z3)blQx8_+N zg&d_56-fWyE~!WOrw(`3G0LE`v;i+-jPFWbAw(VN@*zL8z(S}==(oA=73G^@452`-vnK`-s(f1n1_VCoR%zOup>Cg7PDhT|xyT`m^`Q>oW6?Eq42(W11 z)m)-=8-@r3TH;a8>)&Nbww*P#-}UO|3c{GlHk3}QO&g;K&qG#H@9o)qWNABsH zd${wqJn3|>MQKR`{m8)6Eyfpx-&)!(xClt@3wqDu{6qb^;&s})NhdmJUMyGfiUqwP z1S+By6=!Z(zxn+^Wv4R~4hfPDt=;29=_J%MT#lAxI~>9VqT7EjJaukwA#|j=>qxoA z(HQMo&IsTQYpnsEhSMoM=0er)?Ug0=>k70!jl0OqZ)l~z&+-A+PF||0in}&N;#w)! zpW77mOxb(rm6-=o8q{swadIL|){NbPDHhXDUu5zIH?`KlT^Z-LQNW{OOy7*=X0@F* z4vFjCR0Ecmbfx}eUNH&gra5@v?Wxb##*RnyQFmShB*ylr+tj(NQSz2alS;f6n@vh% z1Jo2-!gN3KBvXGdus9!&euXt|SM0PxMydUj(sOaG%sqGV`#o{x>GfRSb6#)#(v?GN zc5Z3+D~Qwi`w6O+S;=?TmfPUtYGZfj4ZrZQU>Vj;j-v1J=V+Lz$)4S|`ie}l7Ousg zn=yQsTQAR%Ed_B_?Rt2*Ed18#LZf=tha1+FIG;FA922T^mrlk3jJ?19(p`MSuCmR0 zO?SH7@Uerc278lag8qrmzb2gPruH0J>z!E5|GM47s$2d=*!zLO!GM$A5$A)BOngw` z+JQc1#@qDv+f2Ask}oPs!-}A9Zt(i1>$g~q1m(xPvT~1aRv4*%Gqb!rqrCaw*(@QE z$iqq`;uN|m8;bkRANWyUplSW?hq0WAn0UPYHLoeYn4=O2uxEZ}_-(Xapwrf>nA5*r z6l-)QTf9c9ajmJRu-B^Ka`o%hv;GR`f6NwO>^vkUICyerkbL_Z5}Ov@-~8esm4sra zQ~Q5|NW!>mGlHW4%-aXN4VTA%=>jjtYLsWy@f2FV8-qnH%$;4G9TEF}T8MfY2(P{7 z;k{sKOeHev6eO*@+^An^9lcx?=Kco(5@HEDiT>|0)%I*OcMK~meZlVQN77lZbf7{y zb%%aCNJ-wFKuIWb{x_p|OEYIToy28(qm!*1lIoSkKx|?^aedVAi-_>T(-K0yK zqaN}PvL!%YUIO%eX8Q30B`{q40^r(znD581qx2FJ{{!Cs1BaV~j^8S&d;ygA|NgQ6 zL3fef`QXC;AjJ3$ft~-NEomf-&i?N|x9k7Gx&QuV(;6L7E~5yr#cBz`V0cp$?|xC| zHqU0C>4aemIZew^ct$W_gvT3ZhI91`>xBJHkz(DKKa3cX{H|`x_#CCI3HusEuiZ>e z=g+;smjqmu$b7iI1>%@sOKiljD$YtX-KiS`;&v8FBT^Ey0et%z zIf?r0N0qg`R!_$k0U#aY_z5vruG5*LxmQv{$Gp!Rj8l0XCmirPpOe&rf>%9>*W%ma z?5u{72m5)SgTs=|IhdL_1!*1Db-_Ax4&Xuy z(&%&1)avLOQDfsCdoqZJjMdaraYI0~Js$Xuw8o7N74qU;d1{SA#Po{1bhdM<^w#yq z8r;vH51@{XW!uL*?STAR@M&rbBszk^C;aEoiEW@YK)M9$6h$K#hNmJsL=^OFnuol^+^T* ziyOKZPHoPY>kKQs_p4KP`l+U zo#W(SisYd7lOt+=Um3+$3YZo?`KjWm&giFe{exTm*3^l6d)0g<`wJ4Fe`Uf11gDXz zG5vtGj;FeXq27N=Lbt!>n{f}E!aUNDch2tip{`NMsv3ppb2?%P&f0r_A}!p5n?Z>y zGBi1>WDq0T`f}%qi<_$bvp;ZG19#8&>mWn88*5lHGXE?!KJUGs_dEV$VI@2F_WaIQ zQ)N7)`L)(rnj3#he~z0z*3sFLx$B@7eX>_|2mN76zJvNcoPiQvzTC3g<0yMs9Vf>HKXIG^x|T-@6XZK+j}kgNX#yx5M-fhlz%_n@tNv~jMY^r zf1kq(eXsg+_`>7kmxhZ6+K`H3gkfZ?jCIrF`9k&h77}~}H=ET(w*GpzpWEB6b1wg7 ztxsItr4FkOxq8RhK14zGjguj2fS?fj-kkwH2Om>OnQG!4azQB0n`9uI_F+ z-XXPs*O%3_P)Jy#_HmkIi9zhbp_|hib}7)mzo=W@`2CsdyK~9y^c!|^6m+^|kV{J% zW3@T-P&xvG>4vmH;y+LtFfQ72kf-o<$)){ykP#7me)xy{IE3*L9hsnVK1aUotqC4@cgqN78v2i_W=LmY(6 zv>PPULqa23X+U%dA+a1{Cun|Q^ej+H6#)tMz;o>&B@dYJqS6)X<8D zxVd)ehNd`3A5Y;Pc-(2>LRjU3^`n^wA$WpOa1C*lwD{%_8wlhnrjsydz`hr$Dz+Co zxx@6VT{`EHfFPDY)YS~msb*tDZ?58<&Rsb-CJ^AprpKvTM+hz!fYt@z=71%0n*!qQ`U#n2J zhVvkmBR2yN12uNO#vQxvZv()Ys|~7CleVIomV=2)vD+PJuT!t-maPaYD0@$yXiX(c za`UW=k$=XEEX}1tFVzm~N~IzTUDyp1K(`>xa@e*El}-Xt{i|+luUD}R5x)f*oJ`92hfG@1N2^2TuVFX;ez$vEf7&=;QsV#tXg z3R`=P1NQA4)?UuroJQx8<8>XvxXe!ZotIFd6-?L22Vyy2PZ(N-|?`@b;FCiWMD z%Vb00fHbd6@*#uKB5Ub9`59_Ix?`vwe{WYk%%V{#={cPSt?pL>qEjIm8jJ7Feh{{{ zgGD#GXE=N#sBIFR>jKn>hNEVec=*%O?d3b{RdQ+D0&obxTD*Rgj>9d_u1pjaM9Vib zdd~>IYPl`3KU>$&+)dK@k2!n~c{k0ha6GIOr+rM(j?aW=TAPg2Ion23})I{06Up7aWJxrUU{6orh z@pCPYM{LK*uhgXpsXiBWiPL!M@-VJNKA4(Yt?d}jkd5(4WkbmTeUR1X*@9z_s(nw# zA0F%VAp`!+?QQ!X`JlpQf4c!2E$hmPSMPTW7z-|b4XI%i@Is8PA-}_J+ad<1`#m*t zNTJQ9e0#cK`j=3?X5^29-DJgQ^i!AFt~b6v{?>Eg(CrJgjNwd!O5ePBx|?JKiN!YF zCqYY0_4ckI|8%n5hkQzNX{frEnYecJEAF){I2CKiHlo_OulE*miX?XAw%M$2125Q_@H2FVM@qV!6S*LhE*nFw!QM;-yD^ZdcZ6g&B+-T0+3++um^%%7(>O1Z zKh1aELDS)~M&T+RtCFmDT;!eR+qk1eueE6}K)B86N6s7~|67GOfLo;XqIy%6K_P+$ zl@io$k3MLnlkH42-ua?e!}q!7t$x4SUVpXyWTObm=n8;uDV()c=PF0s9vjFbn!dPoxs&=aknKb(({i&Z@P!W z&aZkkzx71cFIbF_AJMbEDjRI_3wbi;y96EPR)WWQ^bwy3Zz zny`)CL9s^c5I0C|6$^FeaMf=BOZ9#5$Ws~+?CL6%xu8r3x6f1BECQJPgRbR?1WLH7 zpl^**Mlr%o8}b zh+q<9#KI=%A1z&J8@#poQ9o?cyf!PHuuX!E$nC))U0+;$@eYA$g)pB;mU8-v@EXF- zHRhgrv+k4sz7L*1uVgYjFlzOFmkd3RW8^(7!33_5Tt3X}p}@<8Ter!iBqwJE5r|ck z>;&V@e8LE~cL3ZR0pFT^7Cj0qQIOa*QrmEq#zg8+G-N z+0Ond1p65ghH8~vCV%jH5EK{E>l|rtpnWvkN&^_Byy?MQ@ zvj={?!64jjKgkC;6BMXyb)63pSGnWB`nIq%+mXFea`7ZJCkXW+_*wJnxngkH>YSup zF$61&dO}o?wf&QSJRna(V=@ncfeCz>CJP^3fU2;=d>M6u!m9s4vzHZP^wqhprn9*P zK`9)^7KrwB^fxN55jQ$us*r2Kbw^TSl(G;i3Cr-kxx#9(Z=}R1j;;@ud)uCFC}ivo zQ-B~}nq3An4y36fg@_X*nt!l@-Y!BCr_D1%7dkq+WS5B`lz54Jh1Y$KdmEMFBf#&3 zUWI6FAN$7PdUtZ)_?h30e6+=|M?@-R0irF3gy7;tWu|W!-HqX!O-(W~0_Ol{5Q3M{ zJJ2a_Z>IDQQ93bIf(-QR^GR8LE`xEWv-2O=h}E?)UA|Dv`!3O8aAt-0 zIPDowf`f1IJ0??v=G;FcMJI?Y9WE=eBsJl6u*|{7iyGfj_cJeUUpK|O;3wy@`;8wq ze-PZC+*km(cRJmz>lPdRjnK!8&BxpI8F{bN5)XryKWkb{vVH$5Q61qT^(y?fX6hTw zU!6&f%nj@EBL`*dlTC9hdy@Y^DdX3Sc`~Kv8>X87XqG&9okj7Y?cV$S4%Xp4yQ>`7 z2{5?Qz+xERYQxrQG5T{V&Ea!ga1OYH!bndvgnP4gM-O$6>N(thRNlvd3D1SQ!`A_N z-I=l{r|i-4JcgEaOwab=QX!M~4YPDk@25N9_9czsozhG4vO`w4($r061wDV6p2XT# zV*-d{HYdf-;Q`!w@9+Kn^JWOnt@ZVF0?6Li0u}c^I=pA5(m3w^+ufay`7+GGoa2qE z0wB3h<~~xLf||Tp2!Wz|4p}o_`{u@R;|=P_K7K1dximbl&>No3Pc|NN-G;`;HwWyz{K6}A4ok&yND`csMCwngy)nk_PyosQ;_UBmhi`(I# z$koabTBp|EO-VXL1qP!5%tS|rJ8Ya#JDJT1-xTs~I#@ph5ip7g)%rW{q2At%?fUsF zY1>h#I4MJ+;(AF?^Y19B74Zo;YF8orWcP%L(9knVj+{wD%haLb8x#RoOk$+boAkkV zc6X2I;xiQLQmL4>77I*~7J2IA=r>4HGwf{VRExdofv@*bwo0qt(m9T9!CP<_-kwys zMbFT;zy7zpYu6KSeGr&v?7s9vVTp8TXI!_yd6NOt)|NxBZ8m2g_$M!eA)GMD_By8U zs-E;%;4)G6?n)YLvwq3u4dgi&uD+IDLDu@j=_M&Dj@ZhIfOqxkQFW?E(CmC<)V}85qhsUdnu7n% zmg6AKwJm!R{+UZioneq@fm&XlyAw$*)p{C5oMUFBalKEhx&ZUo1of}P_9yg^Qf&jYxY>`<<0I3>eI<@XgL|z62YZBtM7iihGh@HdLO;ijTeClTUYY= zcjfP#$f;{W@*K)Q8MYv0=3ar`nA zIz_C17^s~{IKv)3bXdxAH=%M*V@yp#kZBUR@#nlWoS+r7W9KFIZ_Qtm>AbLoi$gq` z^>?&M!PFY8rZhSui1j^`tvEt`>d80s0&FZ#J&`1O5g%MyxeN<);4_}`*+$v(1y?d` zDgOR=Dk#%)IoC-H-RL+v5+Y z@fy%YKDcr|f1vrJtR;KFyB0Y?o-4%hXvo>0GSyb@O9M&I(w*@l;WTM9-3i zVS4=>owme1m!zQG`<|Vk*^~05+&V#}oGT{T;-vR3?(B^?75^dW5yam26jgA4|^yj{=RKq*Z2X!;34 z?L%6?#~&+stF3%s;o3`YUmfqO9@GCc#Qy^Tw-NyG{|6a=G`Sjp+^_%rg_2T&r~lty z7#bq7L;m*{Z03pi@PB_n%o%>H|A%Mef9yL+EC`1Y{gZ?gnwP2%+a^hwk80NS%p9t? z#~HruqD@!iFGYg`5t%4ucZ6LCWqQ`ENE9GT(}5_b?hefl{rX|S3>mG>%Pz1&(g{u^z{ z?aOEkhL#IbAWvjmA91`Rz#@%#<#HiY4KsqLI$97bho%xF5Z2e1TXv7&>_jr)=)wm# zvUXD&Do(X$4iDRi>mM&R{mI`%9rJnizo^2tXx6OQB>0siwaDXFoi;%;-+lZY$WdZ4 zy_sQC@72;FXuznlPL$;485JkU4vTJfJx%uZ$ynhKB^2+A-@XN?xwwPTigkUpA6LV$ z4R)Prd&zcKZzCy#;uQlj?-AAmdSe(&h@RqCx3dkEUpcmp11{;BTP+jAD5k!)Ju4=i zRs{H$ZF#pCen8i_A`vlf!@Q_S5~nG0uF_xu1t*J-3%rEz69LPVRX#a6Np#6^m9nY) zLVmb@#Pv6-Iu;#TmT{^M^>=Q_sG@Wf9PrGFZ7qq|9D-ulA^yBy3kx|6SU;40<`a3{ zfFKr}kB9i3^6X;~t3di;)9G;i|B3fRUTCRa;%U!cP+I^+ve8VPf41@(AFfXcQ7nTy z?7_o_0dgE!fgGm<{Gco##C~AV)#&0%oudkOxoMFH;Zjw6yBgQy(Hh~QKt&r}yB?*b z1_XW9aRgtFLzkdb?AwnQ4yPYxK@JijGPPbO+7b^(c%Shy{~)sO)wmg;moewd+=MVK zQOe0$gcU7L>dFEvhwFEUwAN-Hsxe$7vb9@fWXF|GHXBA60d2ZHg~HcKcgWC!labyH)dN2&rU-R(ea|}5{>;QKsW!$$UCdEiRoRK+#faxCLFf=2F+&T$vZ_G=|pyQM6UKL-i{YP zpZ~0f;Jw3K`!7s5ttCKnrUC&|hhl;ohZ{2O6Vgnjr9BYZy882H{*j6NN5AlC$Z&(V z`~H1Bv$@OwnjXwavvVZ4MPEzK#7iJXX3VHWkbApI7+CX_7Ck{mEe? zTzny?unT1tECv#x0K;V#cn5HEy#C-eSNJ3U5VEWKAku8<8;_>T<-Ub{E(iz`yFU_W z>9q4N1cf(>--+ZzZf%D`M%s3dU$Z$_kK=l=hE?Hc0AR7OfxvXMv1__gRgBPJd9it{ zf+nA%F^2Yv((K}qw8wY5h_Dh{a6&iNA@FHXxY#2ppu8isbmHhUzyW1Y6phUTZ`VTO zauV%dxtH{uTtBKXXc$Ddzkok)fG6i_jiJKTF`{nwj0mf(SOUI!7MgTJ*%N5aYNxJ& ziWChr#e@HoJ;Bb7{L1ocJ^T#RrFu}qm&yDC@jBDzo1ewo#&|}u9jIg)c5p53dn%To zn#2jANCOFf%#DA*TMBbl|E!Dj;>t#Q$n})Ex8xAh1P?&|&mVK0-52m~y%DeyoxK9m z(p|D32S6ywgeqiQV9?4|kzGZMKD26Fk&0QG|2!Ya)8L|~LU~xv3?NSQ%A)TSi^M53 zn1Fg>R~NOO|McmTIyYp9kW)Z+)L{lIEAl0RH1Oww$;t`9R zc+3147u(H?7cb)5)8;|fogX7!Vt{A{g==eTXlH^D&>t<&g3)+%fL=j9i^CbuH+|4Q zo&f*7r=6VDMUqZQdDX?C4nBx=3y^IwYAp$$1Rk$*GzkqN;MkAnVo@n}R0k(pd z2sV^p$=uyAe$i|Mfo``X_6MD7zs~ls4dMO&)MNi;#zrFu@m~-5p%1%Qk)v@ivEdbZ9C9t3|_LA4M({_QAVwV%f1eTxiXDjUX=%3RkgmJx<> zc?+Qg*nQls$sOO8)_3QW@<=O$Qa9<4lv-k0ekCh>=%o&)RQY z33qfvhdFL77X(=xPUyCmMTa%SigavO($Gqo+R$*IrNJs=z#6?U{yzKc74G8weHL}< zD8iP1<8EIQw`JguQQiqjXz1KACMW~|w&TNwOVS=yOA3~EVmhPMawJJNf@!PtcyY<< z@mfZ%prtmNz_$x_o7Aa>?AGQ=43F}*ow#sD8(M-}JRYxK@7xiv^l<#!jI@9}rPf1E zJE|AEO4r>E#UJ+ka94)zD4#!#tHMk=uSnzaRHsIG5kF|1(33BaTeUl+HgFGQ;22v@ zBk?8Cf$7#~2g9YozFY{Fm9idDNNkwL`*Gef)9kkP&JEZz&@qA}l`wycU-$8Yf*gp3 z95hT7g~tO|WHo#`cxeMNid4FQYkmpgwr4?6nG3x?xx^R&o(9VHP=RP@@K8;;*GQyv ztJx3s_w{W-#Y_rHKi<(Um>uP1JHSNkhp>z#7i~T^R9oOO%NBZb7ReFNwi9jU9QhFM zzd9o?(jm7}_R6;(z@Nai5?M%!_X%_3^J*>@m>1wS$owLk8<2HBdym`41;Z)Pgl-pU zySQJ90d6CzJN=b>j;U+GLRu$4{)hsB%{?+6HiGePlQeN3U@?{IH*vJ!))8nI~$`rl(Ez0#-9Q^}prdbcOhH+l{ zxw^{1b7-sAI5dhyWbL?^^Ya1U&-G@dEYyAoo5Tt5FT;3lZf?b`-myEKaIB!{vCgsT zWT9h+@{k*nlRF~&qCl;8k>OzJ9+d=t$V@ca2;o2jD}3@~K@FmF=lT?G=E>CaX#gCMgGG>Wk3%sw|aco>+4y7DDp5OxUd6uRXx2Y=ll-wH3Q`1hQt#f^~y==UN zH!4|~>GDr<|E4Ku>eN?$UjC=1G2Z_PoRs$~IW0hntdUD5 z*Z+K=B)_GNddiAkj_64O{2ZKMrqO6-59Nb{GcNdA24T|NGo77;J}B7Y1R zv>#NL_@5zJcEaEE>qm{*!o@4H^+w`+({QS^O{URD*4T(89Jg@Y7v>ND0jUa;KxD_^ zNX1gbSN6ZEk341+KT)K6|8Dz;EV;tX;0mv85IdA;e7anyMVsW+EA2pi1@Gj$q;>Zp zwxwIy>$aclTGXz`U1U-z4SwewN&S|cUj#aQBsQO!HaQmCD4Dde#1`BK+94bzJJ9|XB z;Zc>?e;VV+-znoQi)LP@dLzQCA#e@>;rm!wsYyu?Pz3G*$T-eD7;FU@t1I+pp4_Kk z^S(9u<*~#gB2mjk_)*VHj!IkvC~RI@Iyz`^W{A=5x=G1eWBWL0U_kMHJu_#g#E`md z-jdZsBnicGT%pkatmyRKOitIx`@;t#t-D~Dq-qd%t#;S?VTXu%=y>qVi>a$-%w&1* z>?PlI>$PvyHflczrWcCq0uU;GXVI{Fl<1Q|H?uYm83nxdga>S6D&|F5!n%jy+;o^-ML@ewMKH@BBN7WaW?|%feC*bGu-)g z^%ur$icFzr`M7imU>;LyVTLx!XW@5}2{E;>9nqT?V8|Xax%r{hkEN&2xZth#5Q%%C zY?}I`7|E|JoqD%eZ=%o%cIfNi z`sYj2)UC|T&0j?wa|t2Zlr%55HwT9gZu#b>d1Ohn(@Xce%Ir)jKj2wp+BsI%ey?koFxvl3B4R6TDq-auO$Ea zZ}A&C^+s*HXkhCc=$hbapCL?>L%B|NstICY6wZyrhXqY?GlpKIdQM!HyKFL%yMv20 zj1ZP&|2;6zdh+S}w;$6q2A=)sQ{KaZv?I;pL97!Cprb2`T`M{@pHx?0ni5s|66-oG z1q`&^^no|*zpzurUVUJymwBc9To91%8@eqCw=}+!A?-t^oVA;1=1NrT`p*bXvme`y|i5;89@rv2I{ zxcE$#W^c1d(v5IszRKuM3l9;(;CN(BIY!1ZHCEDLI*?vv=B?;?{HeDEQtDK5#tAI4 z1%{c1)Wka_##!AnGiu+-$065llhxh-J=m+e%4xo=#%KOY+}^cT>Og_6SlY2hvI1SD z@|}8Q3?Qjw(C7OfYn`id%I(&@SXN;95-`rREh!^;yt_ZyOWA90w5)U~w=G7Y*a2Bf z?VYB_>G4Gh{@lwqL^xre#(zxmspKf0JQH`yUF=Bdg|~6?wyYGgce}dYLg12@(H5Hg zGEapo5`wB7VNH<%S?30y(oLC%9~CJ*g2odT0`p;&rSW!sohGq+&hizNR4uoP;OnDe zW@75pb6&0>U{s38^3_iZ>M!IMKaYQfFczi7FTLG?4FQwAkAH!9VcVL0be2wog(*@n zf|Nc?p>!~1h&z}4_Sd&3o=YMZ;j30ky1?(pYF4Er^ek58PoLo588MT&YJZfq6b43n zkA)W#w$R>~ljL9RS#Ul8QjUw+Y`H)xRMqU`<X`R;+`{CP9V|4Py|L6!y^3kUZt*gqg^HZH> z`2``y+8tk*3;}|_3r!d$du5{){rb}1wVQt}A4GU=cE2l%a;cDvWoQ?1x?dwA)q1V` z%)Uy4bSrzYu$)Fj*XA8;88iD213XBM0eab@%gT-(A8kWPC{OC-P2`=EE%mlm*QTNM z$vW}tvHZ)Vsw&Y3R9rE7tWaXXO7;vV&re?_~a>Ntg+HqT4&)^_#-lH666&b+hvo47ztL5`bCpKhQOp3ULTgW z346crb#`7MjTpMxTJZ7vqt5FnL^k_$)y|xpr)fAU#A$GZf})%=OhC3)rR|2HXYaFw zwLj_GBUuiztZfEIES$;W>A}uwS)mFln zdx3lVD85ntlHWW!_)OJSteW`Ajqf0-iG9&WXSx0IZcpx$cj+#zWR;x&pwSlfxD8}3yd!uee}3u(^8DSQ$27AfYOuS@>ku$ z?d*RXPdc>h5c#~dkD08|#QeWFZC9?y-upa$4{8p(Hm>a3RB-s_L;mzcR=9P|;~=Yx zyPob*C!Y~7r?s4{lTWh$Xu|l(T+reFXAt*)QC;6KHsZ{$C-2Qg;1B38cDjJJwl>D~ zxb}DF3fDIOfRrQHW2)c=U>RTxb5L4-^H|D-!-3x2&>DUd25xj&QBP2_}2CU5YWPBJDYix^Gkci&km-dkFy$7^7AJzho3eMt zODsDKKNMJbZ4z8%n;lEDgZ*Jnuhp9oBJq=j#<|m0`t)gh>?dkI)02D{w5}|^_h-(i zxcV||lrrvX^Z1aH?}_@0T~R-v!?ueHyLR2cOr?mco4Q<$dBD2 z1xQe2>=I$N@q+v1quR-Z%pen{`L?zN=l(V#UA`njo%0fH^N9ltq4EQW& z%sb{bAdtr3=`&AI{b~tf-CYq)7vit=14z7aQkZW4keSbL&wdG)i;cP$^4bxidG2It z9Br7eiH8S<^8!pFA@Z@7!jts(Kv~Yb#Q0Wx=@CWDj@B-%>7Sd!Nzj`U?4~MjX{o)3 z5xm9~T1OuzE5>E=#sY8Z(y%63I+I}?Xq7xa!%Z!%{O%+euCSL{`mZWyPza&U5&4lae zkzL^%MkCj=xu%ZOQXZ2>$>MTJ-yLDTeEqu~9@3E=dQz2Zsdx1Ia`T3N=l`e%X-80U zZIeKW=!*`5*u#_JJ~-#Jn&l}?79P3L2Vn%5J+rnzuODG!66 zmhjtrc25*msvM?&%bWdZ-n-Yz(cB!|$fbOpEVl)69$@=Yl~x&6ReONYuK?j4V(xs18O0o9m9SGqG9sm)~Qzt{eZsrPAbqGd@RiAtHL>*a1#zFtryBLv^a4pwKmD^x6D@zgwPa@XY26<4);aEoH!zO9tk zFN|!E2R8;|C!pa{1~2o*Z07@G7YlWfs0VQweGqqC>Dvp@N@RbG`D4&oe0T!jdC)nu z(?BVTFlHY2BU17KFGIM?YZu^#0P2i-=?4!GkWf6BKp>9ySu+YMtOBp!D%3qhA$Y0OH?-I?RuI;q~(89>Y zar}-}SJ^uK{V?EP^o-_{t8RGp`r&Hd;q8?xU^M$ns4ZB@rZ$%Z@rsj6kBnkQw+qfhcsKYlfTt&9-J0+FCH$rXe zuf$u($GltqWTx0X2TP7!58H$R^o|pxfc{SNym!SXO1?jd6WYm5n6i0tkKa*f9(9Pd(|FwVzr-$^_VtQ&n6;lP{xGSj!E5)5t z2G2cQd7_s$|42#nen9#It&hKk&HWpE8Jf8w3Ej6OY)m&_nl-n@R&4hSz7udYbtfzB zPIuEC`VWH6TChV2DZpYb^->rMi)EW38ShywuJfmO_em-++7p`P+1Vx+-;wT@Jj28A0y#UIoSo6x!ZDKGhai_ zlYe*VWz)zcKSj}Mx`gFSB(})ZG@=sa@VveT83EBc;VoV_| zL%%i7UibmL0^kOy1-#(-52OAzg0#nR}>NAGCA^Salehtzn}g|g3mR2sE{!t zsPVgTptQ8iSDckrZ|`hLma`~hSf4*=RuOBigm${o+wP*3qWJ@Ni~OA?@|Kmdn)hD) zT0b=YPX;=5lv@`t`GZn0{tyQNIlvn}ICyOf9hP4sWDR#;3w2d!9^xoM;<1x4iPz`? zQ%c&7R8xAY< z2p2$;W#zK=k!;hf+Rq(iFP_vL+!@`R5M1qRiF}gSU7^WSbtDO9FDT<>1UYn`u&Ddv zxZ%`Z>H0Fu14&d+PkCVX@Bb9D!7|Tj%ca`10hoy%5;qzb(toc3SFK(4D1EGI_2cLd z0)e+PZP#9!^u;dzsAXJpk!Iyr*w$2#z`yrNQ~Fms=>vCytf@AA!=jo!uXBdKq07~G zP-V}g#kk;ortz(W`kBjaP;+}0(FK!z<7Pzh9Eg&rgJmCoy4AA^+8&&BbOS)K%J@-? zB`d-pw!<8e&Z{mLdb_ovrMLh3^-ID8G_G{@vv&xPYjnOk@h?^D(OzhB)5#u}5eDbCCPn&>dG(vC znN9}@e}l&{l>qYGn3he-NV1RILG2J4J>NX&Y;O~hPJK2TEa1LolhSjPjgN~{ znh1-E>X@?s{swmIYFZwD{T0y3_kOqC(^If4#8pQacfOiPvj^-;J@M(*P=(#h(aUx< zSq85eCdogpY=D8Mcy*@dxG3$nF9ppr*$v*hkJz8o=;lL2bcM3Dm+`;u?{{o$R5}Be zqyY~d^Czp4deD_?@svmHqnPUE;EJ+8EZOMlMoktsJsmpQzPq)u|*Q|lFJ7p_C)!O$lE}Y3I5q9 z8rDJdqqVBU3Hf!KBV(q*SnVM3IdkI&gIu;EiS@k>T4|3vyU8O;mX1HFJ_CWI<&Hcp z-^#Pg9BYp~7yF z^%ZUm7f3OgLM*M%g1$OTPen?CctwBK5?By%W9v6N)y!6O_Y{M4s9Zq`&qty%v1I+X zsI3XR+ZT@Rc7$18jVDbF*z*l4O6Wp}Ks5Vi9DqatfHqm(F=y`t+Ty`F3`+gOU>K#P ze}_NxcsaSGzAr~;%NcZGEApH=Kt@`8h6ylrj;-P&H9IGj?93PUkG8+VZhBlDskm;L z$elC?OkzLX&C(VoxN8DfKA;g3AYx>@cc^4kW67S0S!hA*#1bCO<$ZtNzK{36Uzhn~ z_U0>OaBxD={2vPIQ%6*|9MH)iXk~xvT<&$T>rFmn_QSth#h-hxJhXzWq05WSdFT_! zcCFEo7=J2B$G&#p(02KSRbR6gmfh-wExS;3zq4Z7!g2AR6k?H(=f>JOPc8$`U4rI% zInusH6=Nm)Z93E)9dCUF|HF@au@zV)C4Fl^a0Sl9H1F31*Lx zL?5DWJkvSmldu=cZ=I({)KP2G+{kt$W$$gB$BWrib)8dEzrVlO8vuuxJm>DNZ9k4v z@kD4o2l)MBJ0YK{y;$;chlcwzqi=+LJu&T~)a>Cg`tQ^&d+v({9JOCOT0oS2Pv5<- zeVy~+d^n%hy4DhbIiLAF|9jkH{KiDMnjk>HCRIga&k!yx>|B-K;12?=^~2J0h!mFm zbdN1GQbgI z(yB~549&77BV?6h? z9p7vJ1t#k>-x>An)?<+3Ct?gSxrPYmg#>7EXHdQ6V!>O1hi}O+tn}_7D=n*8EtvrM zBcciKY|_@{irCS-MZ+7_q{`kyU)G17H!S74CwJMApbM$`#gR@mKJo94@v`I@O;XU7u$O>`9`22!j}bX`Xi`x; zCVj|4lD@R&A>XSMO>2lk=Wxpo))dDv0LK7^i4_e` zo+xLc3Jlv)j)L2|Q*giyubLIVL5s_f@pA2c-_f1`kHv{}KE4r?_to-cd0xYl4oBS9 zK}L-HV3~Ddu1PHkj1u;A`<+>n`imA-bbARA)rNt&Z^z-i>%a|ad6P+*C00U4HH|WF zct-xDI{CK{-{4B)1if@W{z(~Yjh*wz0og)#N~bL6IevRm9)#$*h4e@M*Y7Cw|7C#u zzqPafhySv$pTb(yt!BJ8X;W!lFU2d#6;`X6Qu1Yi@(D6VPe^E+US{UoG`^-1)Gjy5 z@K>^6Qu@j>lyDw{JY>r!AYkL2kfm@@#4{AA{1!=^kFpx?BKl*b?qrg`xZ0p*nI|~U z*(5VUo@D1YBMg8ZBwEK%>rv7E3(`R?&qzxC04^9d2t)Wqo}EMSCGzW=zCN%TBBP^l zlH=3m^P9MLd<-FSM?FLhcgPI;!c$s&^%rPIq}*>~7UKi2ELW;@GFeBEgS()vl%T4d%h0ZGTAKEpI@#Wb0PA!4S92_wh5 z8S{N_)U}L&+z8Lbqjc`luU9;w&-Q8~qw2@)a^P{sm&BbPziDn3HYT)z&G=+Xx2SGn zaVLw>JxM2zC$M~D$mYX0z;75oJ02Azmn-%!fG~g9jVnm>!_q_Xryqcq?Xx&8@a?XC z15WU4+Pq4UM?lXbGZgN3)SjOu1@yasW9ZVdMQZoj5{HSb*NC%J#=y1Xl$5B*$TE$A zS*GH4;}RIaQttjjX05u>xd2r}`Vcv_baL7QPDjIF59uvbad?iXKM~0VGZftEOP^mL z8WgA0R84u)0!2f**AUP07Yt+3H!J3WQ*w18Vf&%!RtJhOnYV*pm5cN9mte^s< zFxil}7F+7vE0}|5@u58$3dM*^VJrFH)I60cAD|BWGf_QaOjVQ}l!15~PbOcd@x9O3 zY*2m#ww}#LMK%1B!ig&|xb95bFj1f19nxZs1(^i6kzlJS9QW&hs_FT-i!chG`%6%| z^XtODLJ-JVH3yiDk(Z-ipZ@{p8sL`tB&9^5bnTzSk|@79Z<|-CQ=Vf5O~9#&h-3=D z1qh=dN;38H7ua{9mc_db%v)y=h5~!7?@Wb$jxyA>l$P4UQI!eLT_C&I5j%>$rglsG_;|go}54=2BO!~k9C*b`>Eka{8!in_Z<%($%oJZpESD* z?bnAsR4a#&(mnz=A)k;Ch#nxDm8j*#sl(5X2QEs;p4onkAsd`1uL{>Q(h3A}PI0WKzAqCBW>f$LbNKCtC19A~Kp zy#&as7yc_?>4i-*#FB|Fl9a#5NLh-=xZYy^vIFr`fX@Oelifoz9{%*8|4zc^^2u%D=C5rxiJ=MsLzUZc=Uor4Hz%{b(2-_qy#F8gg!sAhVzjV@o z85hf^=*mp3Osy9iVSNpnx8ZM*pj|`MKfz^PIlFsscpyk5KlvtC_eureCm$@Rk?uxz1*x5JcWj&c&Y9i{)h^dUCy&lKC6Q8!L*X_xYxu}2JM}%1h>uK_6@N-u8H&JL;`l; z&NFg8cgm#6432Fmn(t=r_B%?A(s?kAgRLbYzN5~9dOC5tdbYe6N%k=t2`3}|UFADi z_r&WJL{-o}jEEa@kiwWcfgIDw;86S2bCj-OQmby_g-bCBlk1PSdngVOMKf`0`!M5~ zRD+6r&!o7ny`uUnzHU3a0jUFc^j z&o5G#u`B(u4{clAu?XV(=an0-QcGr&Ix?1Ts63=EyyKoNDezQl4HU~!n@Oim)=?d{ zRPZKmeWcu}PAYTUkWE;dUNX~)`EWCT!sE=%VNE=&V#O&N;v@x+w^DRF8xo3Df;>jX zMB!ZTfdY?db;bi>KXhtRYCH&o=nx>T975V{CmiE19-oW1bSHM4mr*$Mlr+OQIeBe6q!zqRTOQ``*1Tpfgy!9fTWoR&i8Dua>YXvj#>DQV-Ml_kZP9s%ocJ8E!#JJT{-kY~+e zR3&LG?!%D@hs20wc40bFFhQa=07o+J>r)+8M<{LJ6>F3Z-YJ9a4L#gQ39DqPxa6WV zOTrLCJ*V8rBHQVB%6tM*2K~^kUw4mg=C6Px2?jDpnY0M-<8_c~~2mUH7 z4#ycOY`(`vh4LT~YQ~F%SIoK7NDL1n6Q5S4{NZ=yP~mx(P^`c_fWaaI9hol_Zhsns z2QF}M%W5R3_CGd4yn7y1fC9((7428Az5B^7ZyB6WNlxV*X@n~m&%4}*(5g468heR9 zwAHr91PM3{+SJX}rT`ZN)OpgE?ji7P{l)RrfL3o%sRN*e#yj!MWY|X&0N0Oj`p!d! zs?zGqkcml*Ml`cZMT500#k=(3ZmLG5%RMfZ36g>m2|R%l`xheWx!`tHClk(;CT(agPCEflVHFG=;u56eeW(D^e{4oedj;+nO{TF9UB$)TsR_GYMjX#%bxG3L%aGPhklLiFA}H_K1;Wjv)d zCvjg5m1Ut9G{|;KDCO;Yo$~HyJ0C+e;C615z8g|J?JyXnWWi8zLrfn$V?JVEqq>W4 zhDs*)N;8fvc9>M7MfOrI-=PY!(aAyb4{b)*!>L`P8ngkp8s;IdHSi^r0-2Qd0vZiq z(|?kvdRTq3Z4q^^=|Prt=PI7Q#m~)CKj=Z^NZfQ|{i{O4K}cW`4aXqAjw~oC2SVjE zns!l*QHI}SICxzj2XwCTUEtHmX9I5IoIq}n79>=! zn9&x*q9X2%a%dF?8)V6LRrq}rBZY_xJG4hQHSJPZiaezqs<(%ljPU1A(j}9l=;&)* zwp0iS6X&L?ZTHCrjH!pS!x$p6tr_ufmen(jsyEH|Jxbz21;4K}E^n7_q?T;zIUiLJ z7||<#T4^ALp3@(D^Y!{d@<)UWBUR8qc!p_W{yvLbSF0t6N7(1bmQgv{%T5Q1>0C}+rY}kOki9>+d$^1SsG|0fy>e(6MnU|9O2sYArBjYZ0l@QOl`i+<> zidS6sgTg6jXb^>u!mUF4%G4$tq>GTZGJUqs9{}D|px+~Kk4B9J<8O9$hFyV1Z~|O9 zUbv>=e^oZEC=SK?>Ezx z;NzP;I#l~gAY1i&rm~zf81unPA8>(PA&fjnjR0j;unt;Uh(e?s&SR~1<8-4+l{&xk zt}kfbha>UKuR;?#)K-}?`VNDg;bRTZb?In&?i?lqY^di%yQH+@Ha|&mkb=|YQ!o$0 zffUjP>+@fXYd~p4q~ucoR07d{$a7_nj(hLb_5-cxNxsZ)g#GbZD-8Jvdjp+;hJ8H_ z56whJLJ2H8yO%xwNGXKVkx^4`1wUAa+RasPX14Mp2sogOWi0{l0S3oK&ojV2OlKUE z4!oyq-~#N{e&_eM<(soBP@&T-ZMX$88^A*mo(^yoxNIO8=XJ3)-#~`m2W!E)8(A3{ z*9S0Hxw*MPY0pC6#7=|vPwx_6_%<;4fknN9lH1D3AS>E2Pr!Kr(dVv{C-N7@4N!r= z2hH#qIsyRvVd4pg>;sam7UxM>)ZA$`pxLzmSpLKA>CgarJ&kt~1hmsl{1o_lNtx;N zcl=pBg9C<}_T~&c1s((P5f8!Elf$1q0%!)2z(NdjFGe>r&=H_Ahe@{_P{c~6mr1OI z;Gb`ZSSSqb27HFNP_51b5U&t@MvYH&6j@~8uDHng(-me3h1F7xE}6T$yQ+e^%l9u;a?vzrf0$3-Pfy=wO2A21xIkY z2EBkPHLD;j2C@S~UW@1pCpiiYvplGx47GkgU^So}SgXg7LlD_S#^042I-ddl+ff@Y zhU|Xk+&>U;WTJVxbIpOd3y}q37Wj7<5+<}%iqKjP52?h3!0hnzbu>u4-1eDyDdV0zUOSHJ3oWz!N*T5elP^>mBz#f(lV*WNmg?h>7kY9OW5{ zpA=CfqCG~a!9J3;$Wf9{&3_;6-y;8Vy+PaPJT$iD0Gf3QflpoVI#{?Kma^XY=*EDF z)=%F1E^em>uHB~Ad*;aQO6_`jqzjaPuA}#c$-_h&X4{n#v87-sr#FGe_$#GGMjd$s#A6X=hjO z9T|YYLf^L?!<_|{*!y$9eaLVebWM1poC8(_=+j7&Ov3>5d{U^5BHkk^_b?Z+Dbw&! zZJN>TCL23r3=OcrP)R)J^rANsMP)KBqp%S{IY@@Bp2ls9OP#HCAG*Y-kE0&JHnrvE zmHXi9u@TIaF%EHmA}gq3?Omw@LA~F!J|8C=So_Z-$ILrn7=rze{6(DET_S71f=WPX4;&>ysU>{~Y2)`*}Gf`Zn*jd-w%-FcMgs)?04pmnX= zc}Ws`4Qd#ACMf<-wD>Jg!TJ#r2}#z#i}XP59i5ckC^!JUPZGbwZNh&{TT4#gh3CJ9 zvOrn9SDLG7nfbdH6qPQfV<22-6GVFTnqi=Mf&NzbX`767(PoHvz|atBF~qbdPO>$ z0}fJdjUsax7PYzZ8zO19eczdRo0c-c>fvGyE%HyY)DtDBj30|P z7VkOXSTD@my_Op?PCaYLCf(Lo4t2sP5)d$Te*b1!;-${|)BKjt9B}s5|He+idX%~y ztR^D>)A+Q5Irsg)68DH{D&pQKOzxs;gE5|S#*`GRdeASP)nWOQFtSV#3A4%XF z;pV1<9+!hDW=v9czv9GZmH3;_vR#KgGmh;psI=JG`e-7!&_y>jK6Gz+qkQ8Z?}(S zGEud*3O8nJmDoDl?JtI?;J}@NSk=W69e0MC3IF-@{|Mn`9_vg0gBhSq{MbEc^1UlK zG|ue@um<#gC8VCUxzk;XAOLxU^iH>js%n6LkFTc=4vD%CsH}B@aR{(G2qTlTBhQ&(%y# zSD`{j`@Iq8LkLhah@%W~7U6Xs#=0h)%C$J1SN_c^>yvM?vLP}IG&_?LZXY>u`2Ly^ zWx+tI!vt}7NXoEI>noZsuA zQWC!U%h`SJ&Y#bJPI5VTOcNBp(Q;Wcs4Q`X+$`cL2WBFhWUhKYP?o_Ws>lzo5jap+ z#JWa%V3>qjG?Uwx;73Dv5=Mg`T7Hc2>!_l7Ql9kKVOrAp?Gup9!Q;qGWbp_LCs>@# zK_9u!hZ^Px;P{Vd!*u={!JACt4fwprnJ_GFJ+$wKGh(&r^zJEw4}(!7`UOr-qz?os zVxf6`Jc)KG1eSoKOV#3lRba#DNQ&B7wc_#Jh!uSM0Hy)>jV)=IFqrTZHwA@+nqg$; z-T3+WGk&Iod~3lH#fcrfe4EJhg$K~K3r+;+=r&d_A;>jCr}o4TSBQQNcQoMAPN-*z zMjzdM1!OVe8GIOgW~81)I90mWcQOc=s8D#WnWdVg%R&X;W65GoSm_sQ+QY92lq3iX zgBq$+4pCVcG}LlM_;XdkxQAFELW&u3tS~wDvBRab3daT!z=FQA%o|G|wE-v?n{ztS8kSt0nsu3%m z0W>$Lt%f~0Jm=oQ;|z7jMqck709p}11~`O02mCh#{NUI9<|ssUhlb|5De!j_@D_k@ zc)SOl6oCib=n7K8pjdOJLrEXlA7>{J2Y4reK^<`20tpFv19C@gz(EV{syg(-@27rH z7`vMfHbv9_3Y1IwmjrE zL&`~wXI${>!5dnu$HDWKVg(rGe0-kY%SvH+;3KBWBMt<*^Nsjb$g#tNc=t3-kx?&J zokfPU1`cWw!qY~cp*G3no4Sf`Wzi&(Op>Fc_iTzVV7_Kh@@`v37(WpC{Vq%{Kd@F; zSKlYY{sC@i07%`crWZA7F?tU?2AKT59bde8m_5of004|9dB2wsSKiHCj}`<74B$?` zz*7bd^A%fu9e3jUp_n=_@OmrV6l92je$UGs zxrNUoF*eCi5Rd=zgV_#Q0ee-m#dv`%H5SOByRg#;W*E4yQ>g=B{}<5a61Rm2aTUfv z9wFTa<=ryk5%>72$Q) z^q`09VMJ)?=x{?}Ae3yScU=G*_`{QYJj7`Tb`}Pemwy6$ej&QCvPbKByRae60tt1X zgzbS4y$vn1(qL4F8j{P|PQ*Y4avPXtfkx!x(_C80OofYZ*MMmZMljYgvH5Pr;)(kK zhcA7Pzb3X%Y#d@^V;4=@ue{$W$ws&ysC-AHDs_07%QegFQs!!R-V;vi>m;C{Cu98^ z(}H%xNrIy7`6#S@gnbD1BBP;+mjOCK^u6rZ45~DXR8KP7dVONv6w}Hxy*X0>3o_PE zB*c+muMul>>d#@cV$yk`$S4KILpNCqcQXrh?;}o;9z&rOe1SJb|76^u1b(dvjSiD< z71V&W+}))w<`lDrV`h_;hwKW(#u4z5hJWj^36OlCueaz(~;Y_`outwAbkm<^!F)?|FCtF*lEY1qA2j|@x|1gWHxm@I_yaggK}LZ zd2qdhpzgpI&etqRIT*RQTBDLEkD5ekUT$h9ZC=WEUNHnP%U{3uwQ#Y%-@BBp%S4XaBtOVsyp%=KKt%L~sMGN$YW>Tn30ta$ z1j-xQuE4bpYIhy|qNgw!wqj9AfK_o2we5X=j2K7sCz?V$EDE?VrnNc!JBSS*}DA0qXoNd@IlZPJdQVN zY7Y{rU_W_gG%gZclFjb*iV@@WEhAY@w~1`jtWlf7ad?oBb-)Aj>{yQorr`|H614Ig zr1JIiMy%g> zXj2cm7zcV7RTR2KVK}~X`Sj4YV?B(lE)gIh0LPSEBO}NZZqRU#<5~NjviRp(mBlK; zN6f?&nkh9oNC{RlaBWZzpn*`SbQ16kRJdB%i~H})mFJ137+|}5>UYm+o&uR}TE4f^WBnnP1~d zp03#O0m*o)kLR%{l~j%<9NEv{lkYM(x&X+hn6i|U*1+wLR@+kz+doBL0a*ep^76|s zFJpVVdTzf9w77Ex`%L6-I<)v*I+$t1FIko8XQa6z5DCXJ?Vh&~Q@tx=eh=a|5cK%@ zOPL*Q@(hvFh4UaKIk{xFGOrmcwAEL`buu|gFJ}v3jzszG6*;!YEI3W1E;&wm$^@n1 zU!SxrLGJGZN9m;foL>Y~J0{I;cYj&R-{xU~rRwkfraa$x zT@F%^HB@}5<#|QK#c{7&0T=Tm7lJ)4QM*ERq_1Uxd`9IVaZ^hO~e2nPhHV1ZMFXj&eCo|v+oc);BqEd$TAUucj-hbArR zVOX2az%{8%6b3ZL6)>E^EwT0r&Ms+V-yjAt35!Emo2PLaFH}B&6DZcxw*$oq1%DD8 z1h!;RL|qi0?{`kzi9%wYx!RWW7tdq8ZGYT1_Y>>`pjCj_3jo&R3%?F=K0ZDX5d*eV zc&v9q<{_aAjx)c(eDTqu7QW%?Y93^YFRozeI`+*F#2h#V#cSj(?hD+1LMygIP%~w5 zgV9&>2-doghUMT6Gq(zmxkN|+ULv}vxHBR;qkmvL5$y`f`l|*9zU2qR$FHEhGtW%e zYaPk{@U7F+4g*#WaVU?(L2<9Q88+;Ko}Q6(kJFs7Z)Kk=bYdU1gb#XD>J(x%-yV)6 zgx;IueeL&7^E}U4Xe5<3$a5g7T|LYHitNd8%$hsIYQeFRmcuQQ=J_2;qHvpyfk$(A ziU+5PJVZf< zgrqspl6wiFR7BU9b(U`m+@^pv1$Q~A73jQ!=QzA&!)t41EW|JRH%RmCE>Cu@FY>Mx zlz>}PtLOhEni;mjbxkEVWatthat`tQc3A7$_`A(}Z@w_YwE+k?LoC=XfRE5Js^J6T z^TeY7*a*y`b=>`9k=_YM2v5h6&!0bog`+|N9_parMUEEFLuB_7F8vHtw+|$`X4TUK zpml#aKNniOF9b5_C{oiJ7)SUOSds_#U;q>d^#zACuovD8Cjbl0*(+GSik^H}ni>n3 zMBO&!H;b+9@@?5{Phk=PPjs38j*=Cj+CCmd5iu6sp(wFX1rKh~rSGsQ=;c=j)V zOr3G^hNTmQJqZO;{o@J_5kp820Ce&0cgtBe74lb~5w-4l0H^gn@?JB$hiKWZAn3E} zIsY=i_zHz7G&ixb23$3U`z|@;7Lq=n^Xm*gyIah^9Bt+lVSo+cU|hCxkZkMg(UOw_ z6pSadCixU(IMf>Lxr!rA8Krf&!pbpxOv`adF2ZK_Z$+VYMwv2|rZ<;^Px2Iw^E9T{ z2nqnWjQ_Yz9V%M3r-TW>D_wV$tEna^{@p;3L2cZ2ls zMw(rt-8oFjP}9V8w>}}OZwQhN&5=;)b_V}-lKte&Nua!mzCo*!G^B?`atwAB47L#^ zq}=N|=qps_le*H-oS>8*EE{wu&b04`aSSe*h~H#J{)Kk=6+*J;A=W+hkA~0B=H1a4Egdj!m{Rldq*mey#QBUl3(8pmG97 zml`u10h68W{F}Oi@JzRO)^*=`w%6?h+l%Y|z$;ry|q5<@HJ%VD99_VWZ zYTQJG6WD-Yn@ADsO*sZ04A@0Mapaqga``JNXq*hCfi-%ZB9)eCp>ZxcCuWd-rNA6Q zI@4&N8)rtsYj_Xa3!&PdKt_&~X~kz)EB4i!7jazO^1C6uI9+jy#<#s@XLuWVcJK?QghzS z7rxy}A0l5w8x}zO?lDF=8)kksnAbZ0?sjrLOeUa+L8gjsIEDCbdw9g-(hLlh2bDbO zrGr*ck@X3F0M$-aw1|+gpWEpcqMJgz;%`-W%iVcdlgr~l1-Nl~je;j;#$$4&?t&L3 z2f20dzf{W7bjvivN`}dx ztnAH?Ti~?+GYwyGHDZu%>GGdGV_D$ZSF~p_Sfrlg~8;K7#Xz^?KXuRfCy+6%= zvy%T8dgJlK>*I%`UGq~;^Bu;Vvyio0lui+Gs}We+6!5Mo+4j-V$NoWrzi^e%F(=l+ zWX&^DuVW}olSSEjA>!5Du<%G!DVqd!d1|(G*`?MI-nd@<;SRTFj;vXyxt~Q2ov*@(b6)Sj~iO5R4MEUo!6w+Y5n~ARMfmkllAhG@_MJE)+?sFOt8hYpn1x! z+{Jy*%}1T%w`dwT6JBsrV532Kj^eUjrg{!)#!Ht}rGjK?G406s7uG+gpR~nT{Yc)| zs&KuR?e_bP0i87gieeF#N>=#|1?6>5eY-4z{WnZ4LpMzmx9w^~if7oGk>5MFQ{;yu z%Wr&bJ5bG?zXe3lZ)MCU%tsQns@VWH?6uDYMG8;u!c zvZ#c|Qv^)R4C76P*lDNuq%PC%>v!+=&3>1Juzwl%<0*k6Mtb(z7Rt26a#DVLg{SQI zIZcr}dC)2z+mUiewK2-?qVXN!3JCo-8}*82fqy%VY+WR2HTx=_diChe0jiCRG54jw zPZHgGy==*a9?rMS3P={G8j+-=J0{F^1s{*d9pa6UH4m|_FG#$esS0f^F-*4lFRw%(AzwT{`re$#cEp+cy@sX*0pgEt4WP$PRHc74} z{H_T87SfO7Ju>g4bupRDtB0;!UQ_JG8P~TAClTid`?+pQ5;nGs9aOit3A|2xTGMSV zy>O0jLa#ljr=7?R+Iu=)`aZp)Qmjja2h;I)M+t+OtG49=Ze~C^b#`k2CYp!RG&5xa zL1NazxN#BnP^6t|0#3Sl$fnLY20DZ!GFZXW)Xt*;10yT~M2szgg zPbBCxdZ*y+n4nPG@pL$A0Ec~OP`XgxCP1=4wGNv+RfoZkHL{-)zp*m%$$MV zk^I@RFdb0~weE*)y9cHV0{iJo9TEeDjY}V|pYiKH*#CZGxS=XTq9Z+YWTj?B-J?^mX!-~ zXAx&Q6dQ^2VmKE0k&O#=exhvY0j7r+%qAW%TVPt}MiK^&|?bP#NUdi=@y< z67SKQgel)sTr?{-*N|7V%zy%bRsgT1MDC*l#11Onaa6g~m2H*&2FF1=_2wjm;Wigd z%E~`lb$d(`VWZI}MoB%)e9{o0IEyRbqbxT8P+tBN<8W<$o3He|mRN!{qp{c&j81GP z)pEV~ipwr*zHqLe7XtSgaw8*Q!j(T;@YP>;eE2`UOuC^(;5*hfZov91{hHLrKp7 z)A@AxJ0OKsg||{bMe8pj|1E3IRJP@nHWkYx-|QIR0nAZ^Ccc~YthuxEx+L2LX8sYW z!trLXxUQdyS^x*sAI$S9#%s%uECZH z#`S)nUm$*x5pjmXd@F(M+#r|KA|=2DgMg{UMFw(nMjk)`KoF6KgAp`!F#qm@wHemv zt%xlTVJcim51Mg-^Z9cD_)ftti6Z%Ez&i}1u7Be{{_&dB2Ao)GFY&+U8<44nE>9ny zjKVAq?Nh%8(CyfH{Z~;NwbuOzQq6?eFw!g(o*23`i9*Xsp+@F6kFZI$w*{jh>q4&$ znwAX^?%`l-+U|3Be(nQ(3lBj#0saPIv~sqLa;v9n&8;U_FP!BG?n5nIjuJvKNX%z8%XJjziAr1So?yz@P{PK++4X^5({*CAl7KjwY(UC*dv}Ao}gXxq~ zFjNe~`oo(lPo1R!0e8;emX6?K$gFecqW)J3R{RKdFv)`%z9mioaLeq5k;eiwGRsUK zvG?G6KRyG4`jIo(5ITQ+j6xXQ5lty$-wKD_UVxq9Nz-m_y#FSBtseHo)=!vD5gwR- zv-l&>(7{4vP#J*_2u|pcf}*(Vrp0qAuPF@}@*vCa?@QO|a)rj8#TdhN!`5jKpN>`z zO;kiLX9aN-P{=;(q~Mh#O%ACT@r#WWn*qXr1D(ehj2;xhnu5EYQ0QUvkz zXI^SQgtUS%X#=^48y6BhibMHByjcYP_=_Vt!{7hwn5oxh(@%0wn)EEBaQA}i6l`8% zbI>FVV3KFhs2o*FPE9R4|IqwDHX)+dy)nmi5W$`&!D{=y#_WayQDLLu91$=;Cb!Y^ z0tgkzj9VXeG_&Win+5;8HGHS);}|EBy#AGhiGc34rbKFXPtaemBZ02^H#9wqN;rn~ z^gtNnk;1Rxh904$XJl19P$UH^H$*h~(EiZm!4b{+Eg(?+#l^*64R0l&F*$hchr`1J^oVojiM~g95c#vk~<}`(+h+vk59$5%sW@{hdSE5+ox<`N=ZnX~poD z1O1V=0ssLSsr$S*spL8$<}Cqb0*><2kuwweSf7p+cnQZO1Sj1HtQrlx+Lk>hnKaTB z*f#T^%rR5BB-`x%JH1WYybRKvM6XCg0AlQ>2^vcT=%rp+Fm1^90;gcc6#RsaGjiv| zQ~CoY4YtyGNeBE#6N2`F(mn|{@b(N>DsNXHFDS&5S;;&MoaS5{Qz?c@>FKR&3{h=x^#A1{@V9fDe~r)72x5dwq+ z0&O*%gwZLAj2RCvy4*jsNxQ3Yw<5iG(trM$((t1T?#ItuF@G+$H ztKy+taeEvs27zrkbHw)S5>>dMyEuXMdX|518HG@M;DlLGgV7B4x458 zl>{t?8+hK9*!8Cx3wrAmyc7-+FicD7rg%{G$mreY1qj)-4+p&eekzjlX6zfNZ$LIS zeAWy^UKZr@*$6Dapg^d+K>J5Y8t+DpJt1%k^9ayYfM+#~j%$G{>9HMX!cMI@Ptyi-F{g&|u3 z?I(aaFcO!#6|(?J090aeo>@Sm7akK3a1G2G`v#j(sNUuvC8{U9g^D0?{)ghA_sLSV z%^O#(;zr+$9UrJkBC0YR)!;p@)Pb5p2pYjT0L%0|#8;Wqs2Kqs>?6EA(>d(`Y#DGm zn{k~-tNA0?@}Gkj#;=xpXnVHJHa0z4{+=~;K7iCp12CRocmA)9=wcJN_sLPnlUGnc zhyWq7v;%Veg@oQ5C=VczL1x%C-01sMEO%3mC zHAYQ5@0X7lq@CjWHwfy1U;}Vu`{_`Y0ig^wtCS@kq`DeU7Ng>l;#U&1>Sfvie~Ug%mez&LBtjB?&0c#?aD+(>I8g#i$Gs3PDG51d4+ zw*1pjq|QRi(E*w?q7D&=P7H+Igc#h}DjQMsaT#FeXz3f;;z?J1(PMR{dR+G+LV7>C zAhF6z?Tx;GLOOE80jRxka)o+7?rN{~fZ}_-ju+^Is1CPBp%U7Dk$O%Io)Vsv;Vnc| ziAlqJuNg`9K=0Y-{P1{+Rz~UoF!Mov-EXHjePKCKml}j{crX%p5q^w|gj#|f9_NJy zLh7(-OyC%S?s85dyg*bU;(}3$4rcw>8<0^lwA$@0NA-aVw`hQm%#MVlG$8`%5>6duEMN2X>+~3 z7S8Y=!RddXMCnt`P#%)L5_iR|=z%dX2As6UQDr!gW_D|MaTpmQWg%4~h!8+^9*Bqy zp$?7UhAr54xNkHlKN2jHNG#dQc7FJF`Mo9$$&+YO??rUl9>nLYVLh7pmD_yC!W}?x z%1}g?#d3lN%cdMxXzj-DGx?@m)zbVkBTifChYgZg$#Ml2KcnET2qRmz<<0EH%7Ag- zGVNA)`SqC~ZOQEOG91_#l(`P`z1OL?=QIwMn8wbbz z>CTe^<1+Kmv$O2+k&~8)j%f$T`VXBU~CmUiC+?fkc?C87@{C> zS2Qy)3F1i$ve;T53KyqBLpy0E=KXM@!5Rq%wffLn9M?W#q~DypnVfOM7K-@x2b^YX z<7Ja<19CZ-IC>C0Rz9t=lhEtB$T*pTNamQR1**&(oWPzZlX zVbbF2{{4feq3#0@nXk->xF2rf){yvnYA@K9_*~CddTFZ=mDVAH;Nv8YN zrejvz6iG)9bbe`|mD1#rO$|c3& zh9<0o!cZo@*Tk0$1gVdKvmDqo4#=5IUpjiLWPfAKh4+aO!5#}zJ zF}?K!dTFi6XPCiZ#^vxX9e(o=zQTDUiHRHEkD{S55gZzwA9}MA1-(4ZuOk4gR8N%a z)CP&hmqca_A8s^KXX+w7UbrB`o*X|iaqGT`=)&nU(cmC0<_afvon}O9XQc7rr3K4Y`D{RH^`r(tH{)Hm6X>kcLlp}p zm*c(nCPrfItGU$&Y91yxW4DWm4t+Aoou4YfL!NBb9@CF9WLGQ>T}d}We0n1f3Y$Z^ zd_SWtQ4utmosKj|wp#G$rgaQN;)VYGU`rtC+N{7KxaMW+mf-UE$6D(K&!a(N z4`SMZm~ZsMUV~icBm;TfM)3|eP_U}$SEl@3ML9y{6nJeCZ`yQDVLfAE(SgoWXo!yn zgcx*HC^OYkMABI2h^E;VOVsx9o7l4;pCH33mh>e-s@|1n|DmMY7h~80udFQ7cBa5P zS>Y%ucC99)QD6rJ)n(dy`+plRYiL53n~IJ|e#Myf!{RtZ>>ZnuM2FU%P4creO*xu6 zPGai2RJa?n5c7BH;hrB!x2Iubd+htTN}$Q$p43D3By`?^n3@C)zB&9Bc(ahdRRO7Z z9SqC1%$ojal<7R^Olvyxhp?hX+&}F#b+PJV307IBDa0#Ap#CRkt{on{(OAUa7&`8k z@*GYbN=4*%JIr7!D4>!VQ>iGcr-%mI2cdpr_@-NBr=Fj0{sC8VR;R?UenBkw<91w6 z3@+*-v!txKW=nIB@w=Mx%qr|}AKg^X>hr=m zTtlO0bbOTb**I3tFoJ0J^AiPB<=z^7jN;HD_) zGvgS(&#l|_rtt$!7PcA>=2naCN*K@=rqs;ILs@q`nvRmv8ebE)zNN=!_7qg&GY4Xm zQ_IJx=`9guu^=nI&h5+~b$MqMw-nYsZ?^qGaT1+4FUSN9w<=(?iCu*#1)4#0mXcHv5X= z5})M|yhWI_WiLHuq^;Op!56svdfJ(d+Uat*m22@G8+W30`dFvHF}s5X4da$~SdSI! zXw>uM5kr+|_T7VzkR@n!HUE>fY#V7SYM{ICd7yUV-`Y)`jb&b1wDrYfq*j)=JctyN zUw+4Zf0U7xD8jMfI!IV!017PGQg%f>_A}3`HKw~OQt5jl8|$8loVWUS3@lm1qxWhU zT{EOY8dA9ozdZf0NFb+0og=~PliN<;%)Mr4M3KTcdX?WSNJgQO;8~o^Vm7QMt=d{c zfPEYJj%yL4BHzn=tcN)jA2S$Uc*?9gZ<}i73?5b(-V6&-sv4@ZMv}S_wwc~x`iMnv ziOnRsYpsWX?NzFZuNY^MyXlUZ6t)nd=aLl%*ZuT9<;8>q-`fm^Jd{6l1eIb4X%;*) z1&Bm5Xof1w>Gg(V`ipHwH5fD2UQ`0fptXR|qO zgf+zUMed}LOy9|gt0~%kp={~mBcAaonl&M69ft<5X^5RTt7P1+&w_jS0&~}_#MSXO zN&E}DI;7IJPa3@PQ4KDbP7jefC7Cn|Tzz(nroRuUWP5iSwyb$pbf0ll-Ejl-IQ2@Is=Xka| z>p!oGTN=p*T~%=mV2*DkaNlc+zmWUtYFu5}@aHFat*_XfC%xQHdn9PPTz=+s0@&!E zjjl^0{|&8^TAcC5(CwA$rcxzq>z~i(aKQbyd82MW_*#8P&u7buha5AU>GdvzDIsOm zLiKp7=+?pFlNKYWj;hir?<>!Qma)|#BxCb3PY=K+&KU}MLY)owhDSydBaiOE?>`7& z4OZ*nu0=MmGhDJHt4Rk|BxGc<*y$@*5ZeOuiYv5|OrEP+)KVF`yDBY?Nwif;;&pf8 zZSCw>2&46S!Znot?xLWekhNA6i%KMd^dT+jqNR7&eKwL>?uw2G%;9!g8Cyj0{Q$&i zF%qyG@I>8d8hjG@*>0@S(dNM&wMGMw#8md_o21UHkZVz=cXS@&eWhr!?Xz#+NigGW zDOvUhsuuck$)5@WE9U2Rflu$2Az*8669V2bV7U(GXnfW@!=I3D^C@SrlTcCxk5g_j zDYiQ}bUFl~XVG_kPVgt-ui<@Nj(q0H@t1o#BjZO-PW5D|S|t027jg!ixukHE1(Au! ztPdr)3((DdypcGUmOn(+Tp@r4)p!JPb0G7Ay(_a;OWlyooiNX-bq79&p2+RXG32}@ z%9((uwoEbi0)o@Lo!y2F6IBW;Wrl~36@b@2(#?dd>?cQ}H-kqkq03J1XPi9u8 z-UIywT*7t7;}0?(=taQbZKYAeI@oIB^(4^681ll=3$ECpmnWgb|ID77pnyT_9rYhSphPAP;V z@P8>^zFx7#4S~tQxqji_&a3`Y$aK^Pi(m;_ir5zyWE2#w5b*O!%pCI}fdU~@h}Q-O zBY7}PO1kTUDH?2d&$d!^Q#2X@gYrnng)#>3t|zz;m>*s!6qk~0#|iULwPw-2r+YFl zd)wHGDTepny9am1AR6s3Q{#Ve1ck4KdTGP{OR$;H0SgR-YXdcXTVH#YV&ATpTQJ+2 z$?cL40sm4O+VSiO7A9IKg5WN1&(T)l(qf;QmP%}o(68R)HY|;-U~1Fmja`H5hK!7i zYtrmkf^RyL*A`JOPN(rZCF)Wq^WDg}Bl=Bk;pp#9b)HB^NS5~n1OHwj78o`i2n{AE zh#ZlvwTJE9&v*Bo;kQHVK}`D8oNV;<&sb)h1YlQT({M`d4n6Spsu$DS+iynC2cn}Q zfwN2HyO}7E3*kw}#yF0a;I?jt7zmG|@~9VJ@Lakx*Mk{tEbk%s`YpKsi>9-T%4%)9 zHXz;IAPv$bpd#HN9nv5v2#AzQcXxw?0!p{EbeDjVqO>4_bP9gwy`T5nKOAE_L~z|} zUF(cFkNM&D!k73T{1bgv2hifCRhma|Mzh?iLG-r8kCLLJIoaAIHOLLQJFb@gSho*- zjcUfDharW?y<9rD4`@3)FdRdiW2)4OQpc5B9!k)f1-go<-JC|+oSME+OKTCJ#O=O? zFk>sydFX-@Z^P|WQlMu_G=d>Xl>9mMo1{Cam@f{vLou^p$SD}a}O9>L$h+Jy6tXM@`it2@gD@xz&LbedBq(t zO9h$%bA*c)Vc4NEEX0{GJgYzaAR{pR_Q7AhYr&@U2rjQ*unL6})E;Q&(1dH>dEN=9 z(fjxq$<%}bs)Ht7PH7%6A=%qw(#t0o{dFuJhMPY|GBE$0O%!W(b#I5j2JzkZPY z3JpET?jt!@%uTMH^1CHLp-G+;Y2bxJM)8deMxYU_yf(3^h z3DM&!b-Y_<&ak;0boj;y8zV>#i4MM~5``~DkS3MSS9#&-Ot}2T+Wh7R_@kKP#NO(c zB_4QHsGyNsTm|AtLtf)53d`oY=E~n5w?>!+S_v4^#{IReql)f>F1X&_Rusb4SctW1 z8GZXoe(e6P(l3juxt0B3B^M@L$7g5Y^rlptz9xE%DPpRo_6!YvXbNWXJ>a>MVTZ~w z6{JOzEt4E4Mk!crGkl4T3N0KtH%b|?F|>9&usT$2(h&X(geMrisT6^B@LUM>NpJjr z0Qr61!XS<=UeUpAKC)D@bI{i*t4oAod^bE%4%5Z$oZBtAr@z*#}%x6Gx%V)R3M z&jL-bd?;dvI;My8zq!RVF3ez3qT8AAVip-~I3j|>vYtFP^4GxomsZ`U>)pC9kdE=o z0k=BvQK#(djAiLvjDNHUN1~%C=Vw!CG1~9odWM*KzbVhRJawY|OVvnEU~|4X{-zZk z^TpTEkD_$*r3AK2)b;X0ML%ux25y{U!EU6H0HhO*VAc}}oL$<~D!KFO75bUSb{ zBqe#?(HweuLeZ@1Q?QqRd|x4e6cv0=f6inrs4=uh!4w4>k2z^+@-1TgQ84I}% zHDNTrkch|(=-fO*0`I17NClU_qGXc4O~HtO0tqLoulcFEha9AP#`kkgzf>*P&PkGIETeqq2~=XfHxRr;j%d)afso>vH6#->nSO^N^1AMD<5=_;%W8ToJ7>=;BY5uv`Y1G5(N-U22+ zBqxq$-F1YacL>QNMC2OYt)~aL$mGu-`LL9$wVO5WGv#zmnJ4kRwDS6vGY`0dJ-|{3 zNGEdAtysf8TLShjqpC@^buYm?2f(;5r~l!J3!!G+zV=xW^&fy>+6M{?m`bgangq%eB&e~0HV@JJ z!&XGUtWVs?{%iM<0QEUfM3Dqw6CQj7%jYiO4D9lJKeD>nH!^k)V{$#~i@ol-ed7uQ zN>A=TXIE9Ndo57DFg<=w;szhcH;A~R8-bb)d|n2>#jJlHc(<6o%D4)cX&7rya29F7 z@}TpdvKNNHQ*;l6IRNUYrDu}=K<+t&M#ly_ylYs;wZKxhB{aPWJ_+G33&aMms^kNV znh7(IeJsa3L^;YNRe5n}4gy@T?zKQ{ZI#ak*S9?gjCIzB#1Mp^4RYmx-Zz$WuTH-V zMBOJWxddrZl%kNm0lETsxjk$6st*7?&?JDGAIeH6CvHkyP(EcMkhU$(Rl#^vTwV`h zhbi;DpB!D35_df7?#Qv_*oGTN{rY%=^t)P=Cb*0H;H5Fg*FJP80%5r!w}N8VWbX|< z|Cu}S^PcXxCv*r=D0f63Z`6WU0emA-#0+q_f)qXbPPvtui&FW;gGt3mTY1^aus{K3o0fQz17kBc?7b+(Wwq)otY;uZ{$&ZeqvQ%Fy4zbVqL?4f_ z=KYctg2?X;rj2YMCgbI?K#EgHT23;Q<8KCwEDbI3E1gJ%;fKO@|L;Hh&fTlVW2<-k~bv{Blt zCS>P_@9MjGWWw7BW3`3fl7Pa49oKsu82`O_wCFuOOhJX=%(_(_$r}(JnT61^EJPoJ zMS{k3er;SPIv8CE>@tBvT`A+hk!UO;&7*s zXEX~sVI;A*1Z54Z3o!%@4jb?Z4<@0p&c}euNNwkKm*015QbYHF zutq>VXxfdvzJ)Y9&H(T}dtvM~@GroHH&&+JuX+{zWe%qPc@sL4p(WM8JYlaFJb}9q zA3S?{gW|yp94T?_?IS4uGpkD9f%~sWZ1~)XnwUNn&+XbQq9$W3UBfYL467X{L z2Q*uY!k@cngPu|jz}{gtVLp2z66MOV4vRwKDhG+V0A9eD35^28-v9DEgG z{6}wSvhF7MNKMVGNc*LWo7%9jxkNdxL>Q{Ag5EIrP7JyAOLY1F#v;s|SmTr=)Q3yM z52a3?oJSA7ACFo|TjGg(l@X+waa*OGvj=ict=7io@uDgC!h9LcG#LoNU)XGdAMSt- zrqhf;{)}P^s-O`zEL6x~c`lyffxL<2@*Bz{{BRI7#l#7Jh1mKM??1cLMTV_Co zE;Y2zp(4h)Nt`5Q)Y%mM#e?!!r$0xsunjq!)KB7t9fOs1hOZywJw|WiJW3dzWOLDai}l=YYIc@g)e9^6)swQX-Jj+C zCeELZpjXimLdvhbFm>%_V-16h(Gx|hJB(bOi|LpPB>3Srq6Dn&I*oP5f|bn7h&{Czq$=ipe7lrM z?1{sbOtI}L`k_W|m9wQh#6F4Lqo6mRv5=9`{)ZH5660GVj+<=hy^O6fU4dogpy;}G z#|KYnBIV$xFSfD`UJT^6E152Cvvzum@>x3j<>c2W%%SgO1J;IL3sc>~QN`Xq`)#_k zpfSoM;(AK8OSTj+nopCRdjI)K&l69@A?yYAxX0wX^XFYY-~14EcQdrJAqpf-q^aVZSqQ7NdQt7Xq8SeYU#UM|3nDgQ9{!Elx1ZBQ>mFuqdqa6>iah0e9EcF6S z7iSM{gwq#M*eAU|&44bts zREsm8v5%?9j4fd1z-sNuQ5mhP4sN*yQKmgp)6W_M1GodBR8M;op-q`ER}Zzs%HQ^= z$1YSPVe)R9Ehx3D3UUeeDQuR8VSMT>K8^-L6_)WT^*!q**XU0cbe@l2%CFn1W0p8? zV9Dy5B1aC3T$?UhAZdxf7TOBQ6^A;yuNuwfffZh5ndkj;_JIHJB1D1bl2aNZ`T7OA zDM3%KL&X0rOQ*8nXa%AaK9G;+;8U1Bl?u$@&rR4_y;~p>LQyO4D|8Y%B{Oan3oWNLlTK9GpI6Pu77Cc zzLW6!T|Dfx>qr)CC2!`P$TePRW6vp)bT6pa;p(*F_t<0!Ok20w|4|HFjNc7tQzs#TWc-t)2{#9Wh`5)1qr^i^a$Q=b81*+U3tMm7yHHbw|V~YJ=~_Z3+EOc+|4kSEqYQ5e2hk$Q3qoL}~hc zhh6pZHI`~G(acy&XTr+X1d*$VxfS-Qw)E+D9$>qcRcq7nytEtpLb#*p73b2(7P>rm zDp{kJGm{ldIv}Jv(eSA23!y1C&ciExMi`Y3)Yj#l7; z@l%_tLsLSj8>@rNSk;;*OcAw(p=t{98|*U5Bor$J68&SR5_5FPoE@vW4183P^2Nv` zxmA`o*HKH(oZU9w?f5*j>kZwS9F7IQw-;S-o8-IPX|x7%zpF971$=&aHMh-Zqw5=( zGO#MmDX9laA%$DCIXvI~n5b=!n*!SDp-0d7zA|(iFkw2;xn){&D3XIS8>ZH$+A1(& z{qqOhGAwu4M+4OTQ|skK6Lw~-qKXpL*oKIt!|u|cXGJqJ{gYbUFX}G#abwLj}3&rM|@;{4;_uL=x31vaENg5Nmg(;70n+yz23d++ z(YnGZySTV=hO9^E9xMD3W=J17Sh=5qZM_lC7!~y3fJco#9sL{4XKxgJrs{cAQo%a? zJ3dr_84GI+(Z+YH9QEZ*dFbhO{(;V;r=jNuz#cNLIJy_+T!&y*ojtbNLWm!p_{4Mv zzqlDRqfnyWkx^|t1U(kSjudD{2w1wpuFn?}e_oK%INS(*+Tk^TGO+Ew;jK>{ylPM4 zk^XPNG}q&^x5hU!)kI8BBToq(`#uTZgK$iLbW|73NMM0=jM9u>^hO_;6XzL)OlBdJ5yPQz!%#~ebz+?T&i z@62$LPI-;+G|CYNcpIA6>ondj6ncTs#vs5uMc}t; z4A;W~ac>oxB+#Au-~9AnMNGQO^^Xh2R0EacdoJyBtj51v$ zf@wXBm1%l7&jG&YG7X7&2(%A&&eINS>e&9{?P-GhTMRPS7OI;@1l=zI1q5z{0{G?W|OfP=m1^nylhCiEd{I2!Mfg>FNr*-&?a6jMs-UeY|?eszPG)^e(4a|1bK6a>;GZo53(@Mai5b&^0>K&E3iW0rVy@p03L{L49Ew+ zt&MK;C3EVWm{a%G_z|@26(R}Jr-=SXdBhrovCy@vvUF7;P_Tl8AjYP|bQWrILExI~ zaV1JZWmbAgG*Ui_QR4Pn33U9>*y^zsY9G&Qchy*i5VZFVZhH9tYxHEp9`?nQy^Da?_ySUAQKr&>UHe6)$Kv^dj$ zUPYer$_Lo53j*AV&p`7B{GeJ1Yb(#{6)V%M%X{bSohmN|T$czk$6#ayjv_i$x0|jV zj;9Ye6QIHW2h*!-xFh55LD2X%&}UFav)<8MbIrsKtX=f+`2qP+k>k*JAWxO1ROuHS z^ze=mQ9uzaWJ4NERHVNExS*|7`fniP58#IN)?2$3QRT4ql1_zlDs$60yo1Cg0MqR3 z^wg$t->YoEI>cBz#9YgOrSA~SF;Z2Pk9BQ_`G0|g-PPgBTIBpw>9&GYK%~^dc;)pM zN8R*Osm*ck3R-a2|B>Cvi5E;>EI`L2B+zU+#yt`hrd;?}iXp#d!`vpg8!vqwtMClM zsO)b*00{$m@kz*Ce-W~q(4Cs}mn%_;;fj%eANy&-h?oh!%NI>xN(o})7)lLIh217j zz?etJ_;z|58++(!WEg5DaModv>p~^`>1$oq!n22*&hcjKv-{4U#j;ndS}PRQKC-;J za~KnQKc}B-gGbhS+Ryv5TQhf2Lyqiyk=(z-!%gLkS)}&2|J%s~^?QwC+s*$VtaPds zytROP{X)wk43(b%|7BS9eYqzK)7+YbdK(l^ek_OY@2MoHjU7X|?vWR#BP2-N7=dk! zyHQ@>;YgEK-3AsI0ATF0bp6gan1-FBDPkdTBEuPA9ONSVwafD_=wJ^JcrQ9SXl_Gg zkUI>uCmyLhXnl?)oGts-sDd7hI6%8KeV|%DUW9V^+fe-H=(|VitD^}t9Bo;%I~#=| z>>?Ay$*+ye2pdZY-(IH2bz16jlA#LKdF^Ac5Hg5x;J2p9YT=qo;$fkIfp0V-WM5k<|U(vaK! z{Y`g<#Vz_HtC>i*tTLHR*tmZUIoA#8VWAVa zMcNJz#^VG>NCt#HsY{%)Tm$3>wK1}?G-6n2rt=L=L_5~at7*v@J)!Hj?H86tH;Bvd zCe|*YS%Yy};<4d!pH*U;#c6O!^Jf!{w-!h|6;_@vv9k}!4s*xOxg5pn*^A<_&Rx=O zDR`lV=!rIPSjXG_vSB%II4d&bX3}9C$|i7okv=%U6T<2q&w`<|YHCpVfLcwT{0-}4 zX~9hE%tgid|01{nK4@s(Ssbs_$qx1>gcN>%pFfA(xVgTxEL4HQz0Po1H~H>Q7R)%CF~LCeR*_^CG( z0w=?H0a-tAMTR@v@v@PB=O>tv<|&TxR!TLSuwgR$WLV9;_=7ro7wj2oYzG~^7U)ls zG&#OZPY0K1IG|B-@$zc^dm@M$*-b!{6fr0-4)6pYi9ZM4Fue#(-8Wo$j(Jd7%?}W) z?3IPyofE+CgP%^#S8b(vAVEnJKF>h;5VrUXxNjKgtYQVFAnw2E21 zhe4ty2e=nNr>Dh|+>INTxkIX3Q7+9o3~CKrz_=TJbjsYSrWwr9tI&t+Su3`zUE718 zyJ#J(m84Y(E7*C1^kD{4_i!0>Hg`~ZRn@30jfcFKcC~ZKAQ)wOTiE$?2*<8I{cE1} zuMpCp#2@*%9y3%fdGKT4Pv6GF2voK={5VVf=0utKdeh9`j?J}E2nWO168(c0W$aU{ zFj4e@4ezS6W!z-Vr3!TqJRr&ty=L4kLF*rxXVquL~PWOz()Og67tW(&H96 zE;{V)F|E)oXZ0=KynZe=S6wsXluYYHn!(+HGX2WXa{@3vd_KYFl)EE)U*$xv)|}se z%DhQlgSNH7%m2+48KGd&ypuCPAYF4N?IES+?BoP6%<#d?&U(SSdgM;GRW?xWYliPu zT+EiZ%Sd`5L;71CplosmN|(QM)jI*I*= zt#h3cQg%m}27-kR3^2gZCqmbJ`jl48xg?Jfrp>h-qP~yLpZ%vIK6yolLnt@zBf*z# zn>oH?kRmW}J5G~s9`ptUvS6Nqo5AT4Jayd!7w|*lvbv9iIhakduI}g*!}3rPrgo$~PD8fDV=f!hK)XVqj|OS_o{7`n zrlk$3!wT<7xP9ViwCjc564`K{NmCKR3ZwZxHJR{clmCQA2bgNe*8JPA#b_U~5QA2t zwT;hy3dq#A|HOd{r;Ok86%;;Z^*AYFF=?{sfHIV8JpBXf26s<)_Y@3TB{rPHCX3bK zjYIgFiKwlJBGvR?jeuq~tMdQ(;D<6>awIQ57Ujh$!gjnZjrnUh6cD;9McUa;wOBF_ zteF9brpA<*K<)#Vm;H@9aqyi|*vf;#;@6iFIFbE2fS`MNakq+UzbH(*E466%gU0;9{ic~|(UDxgqb|KEY0 zz?VOid=1p}a6VKH>M@NOdQI+3idyhoee;^)X&g|>v`L^-bMqP zQ1K;q1o!xiea5<+cIiW`%D|U`u*t-8_T;y8?jr+^hCDrQ}ENpR1Ga+om~${P@#xbGhRH z#7dLGMMUjnlOqjxzzR!lAHZ5cRCxNCB*OZB9sj@~pcxNRjOR4d)SnRk8-`R^ zv_b6|5w^H;;QevoX<74&pE9^0?AY%iNdKv==mLtC%V~J8uG+Bs3Xn(3+m`B=Jv`_o z8I6lQUC*@3l}4cHoZAi*@+K%E_(1BLfht;3L`s%QX93P<=!+ zx0kE9M>SxRH?`z%VH)B0o-ol3w>&Kj_Qyxu6L*>OhoYseIe&Fl`CmJ-+SPpd{aD?- zb^GJJR4sYiR~KTMhQZSB2N>4ecBLr!!IS)D{K_*GH)X)?6T1v6tz7)AvetrSCa0-?RQ9%d*V?snGM*`<*kOa3Kjggj0>GKl#0b%jp-mu}W)#+o5YR$F zE5^my0mhKjzMSrq8r-T%K8Om_NN$5Lb8ASCZ8lRtC9}cD!<)p#mfh{L;HSk;o)RO( z{0#BhtLvp%WYt@|fJWditjJ%afO)7wXB3VwOc2DF7 z69_CoC}Y8}oSk|cb-Nqy$deM^1Tp3<33W{ab5EfPJjox*4mLWQyWMlc_=Mj)c}MrTHD^wNr%axqX88GlnW>{?2qndkSj0|`9&CeG7ws*eO_Jr3PH&hBpZJU0#rqG zA`|bgeS>~)sPHYyAYl&ri&KVQutle>GWfNCuRc`>sJGM>zpx(5zkOK5@-x-W7zHM$ zG_mNDY5EH+k)TJ)uwKCq`5FiD04habPT?kh;!@MN7H*`(%T{3J#=Nq80~YRihi#X} zQ!Wk(CVhU&`sXKMCSZj7>I}PIgco+qZKAW(vYZq*Weh`+I*q*!eYQ+^#b}TlgZ$2; zl?2f}R6@@h!(JiOcM^9gnJa~FBEABh*(X{anrZBE!C5@U4QOR}Am6_G&+VKnT0R?d$c*0f^s4m)+7Czh1Iv!Fe%I6kB>J5++9eG~or%_2-8pxnm&Gl6@Nx4=jmHHDWRO zi`)k?2VAK?8L49zde^l=Zo~9Dp<3JYH2_S*0=Xaqz97lkq8uQnXW}BMYXaq80$U1x z>1VW3%jw%o;qGMxHz~lqN{XGB*~_LTl*A*LTRHBOL=zy#6j(qV6z=O^pvFONiCYw= zehr4OYL7vBu69)co?g<2Z;in&3@PZC5xu4L9gEMGm-7&TY@J=`xW}J3OeSrI%!7_% zUb~7Zy{>eA(@Fd!+iqj8&l8goxqbWBOuQ9+_LGC&Zzuw<0L93Q?Az=}*R^_q&BrPr zg%Zpp7>Oa1BV~X$-Op}<&%snE0RsWqJ$Mj7Ebz<)>-Xy-?XG{s(dlprf0wp4+@6dh zV(ZD0IiI$eex>L%swXPQw+!Z1~=91_ya$4ZO8NFrpw+ajjTqB6?@hny6@ICJ;B(ql~aj9-Zl``I#Y ztu+JQ5PCR`!DY*7deVQGZi!^o6g3P^Y3LWSN)A&M;st(>(O|WR!I*ssmG8mlCea@K zfqsJCz+iuBczwcpOJtb{>s~1rO3^aoZn~gX%Zv~lqJkMoM7R>cVj|k%Pj)S;M(SZn z8D^TM9`xw!X+zWjv0>wTi6b-vY)9v9KBr7u+6R8?tP+-QZN7#XqiHjp(yXg0wC|o> zA;v?Q#Tg=$CZ!f`VTFY$Lrc_r9oF1?5guHMmS0CliJKw`4i*KT`P~l^6jX!EBK8q! z(ZM@HsVa}y2_(1c%6-WDD+B-9GXV3{K;H^yOV2sb7w5|m%Wo+hX( zl3T!46{FQx;IH2{)K@A`Qf@CVY!cV%{Os9Z1 zVNvr$WK>}`u8%bAA&YN%1>C*6(&nM_T2FKN%tCogg5BW6N0#T<319S%>rs{Xkfw=?NL#wmcCZ&CGJ~%ymSfO78TX;Clz|N zTD$lGFbkyf7>B+5djGhUP?oI&rSCRN>qpXG`!j|LjGIGb*~fNUYh*){xI07979EAX z@)f*eW&Pn)(lsqpNZk9;QB=_PDT?cyjJFAYR#y_q-XO<3!lm(2Zeid0t-p+@f|2*foNm64tkJ`0*}R&qYId_l+F=j#)_;3 z4<%2zTijUdNHPga_a`*`_I*M2FJQ3ZZAR z!`Y^Z0dR|8NrI{rI-j(V(f@)4mLXZi5@q<^M8wkCVN^b$51vTm8Prp~*4b>pzR;ht z!7Yb=TQi)i^8*7j_$<+@AeIh9yEdfA#-l>R28U)x04C@wk1$5VLT?dBpil&RIVwu1 zOqT?4(RTi5Q5WC`fOz$i{atsh7chOmM}6n-u}Zs^M{3C89!%e#{T^h+KRG$ERA(Q^ zj>{Lom9R`Ct1V_;uOIuhmegD9SH7=ILLRFCR_5RGCRT$?8P84mn;-EFpCivg%k!JL zCW$`#r?c>ao?IbU_ITAXKV003|1K(DtF*_CRbGOy((Bvy~b)?-G3- zcI;pVuSHP!!%feW961*kfPtBphtgugq69`sLPCjDuLced4iK?Ll^%HVzx&;rd{MtF zcqH}3#F!#z{dONmMfh_kjd>9W`Ek=K&9bkbu6JEj{kcsW-o6CkmoGRA+}+)+PC5WG zwJxGRg(aOei(tt^`_gXdn46pSBGpKqxkZbeAo_O^x${( zEwgT0TSpr&w`P;ZZ*DkeSo2QMRFmQpSR&n%)S>~}MQV^ROv zZEbgU^;)<*joec|?X9yN%L2>xKoY6WClujc==6?$N}M%&2;O~K7jS>(t%PtalO~lF z!_I*>_;%6J(VciVY*bVWkN&^fA63l&2O+M%7zB3?0GpxIKTLt)gj@5s>1jxVjTc*u zfP4{QQf$lQU89j@;n1}%!q9Jq@aMoNyRSI@**+bC^ZgD?FUUTo#U~j^5L-3mZi9|W zm?kt&%;184OByROr6ro%6cJzrG_DOdPztoI6GPOQon5T6GB7(XE)% zK07-DiZW15Liv1FMujGNMQ$-?f(rZk>_>-w*~Zb!O*F0}AQV^V`=7P`KqRvbdw0Gb zy9j+&>)IGYcI*5E`de5oJg&7?hJi~e(f83Vi+vCVYOoNi3>B6!?$YRfU{RmT;%W|= z-C2UTh6i!ku&w|t*;zxCFT7vidsxLlKoQIdq({+INhJ1dqD$!L?*Ub1 zETcjN6&jnPt#|QBiLs=w;hXf+xB$J_f9@G4B0zBTiM6mlklGOb6gr%VOrf6;1@R>I z%Z`Wg$dUzH+uBP#^48Nbs~Rz|s37$AG?M#+%<;evi~WLJNOJ}E*DLURdoBJzXhC&3 z`(m*ZEg{vRe1QISc{al_C};^O0u#Cb^#%$*K%_(3OsD#{nwYpa;P%sdF9-g(827T+ z`Fem@2EP*=^*g-y3x^e8=jn0L5m^rKO@pq($*uuUOb2p96IULidT?O?1D1&OUZN6$ zb_&ip5%q2E3*mYieiI}7P3|rB^AGly;2mM&NGZ?bH-8oFIT%+$oWeKZ=l6eth%Rct z3(r*O0u28}Gwrt1+JP9^F!s!@=M!(pm#AJaU&L={(?veSLQ}HWZKpn=*>px&WJJbj=Oa% zi=YXE7>$RjrjTa>i=n4l=fMze`AtL2?RmS8gt)l4m>9=P1ydaif%GJ_5n$N3xKvTn zz2G2KQ(#=AG8=nWdA|IYRNM1E#D8Ab&lk$1*mvREPHJ#%CQ&j=FPNa&!&Wd>fjM~y zCXtK1tsxI|RS9#)GK9#xkRJGbi2K$8Y32v@8IpHev{;CTHr%Q!s56~S?#59Wp%}W( z^Lwf!vdL1YUM*U#NbGhgt@?Kl8-ex}&T@T~@Ti}`*>0lm=r+)aURGzd?1tlpu8Kh* zxEfoq338Q2ueJ$(y;cOBC=@>p-B*L>xUs zDk=QBizn|G661rNX4qa#NT`iICO3i|+V-|qpjC~MpSx|x6FG;g6d#CC!lLa!?9?p) z$pu|HU|*A;zwJsGqj-r_xzRo}73!IgaHo(&e^Xa1Te}3+SVN$Rx34F#HRxW?@%*2& zWYpR9Tcqv{^G@As+J<*xBW}YZJ*Xh3DI?AcHGjLAX!4bnfXsuPlgoOCY5rx{Z?_T6 zT9@NP+_*UX`$Wgr{40!3pinirvIFX_-m;6zg?cRF<$eDc@BH62qiUeQOUH%%lU@kJpl{cQ+Hy8moct>Zl;tprk8=ir#{{O2o(G8Gk<=sB@PGOl5`nE0Z`nhOlfIf|t zis3YIJp`r|(S4X0z0b=G&!-rs9*sN1DWp8Jw<9999?;_^PrQHJtj&CcD@hlta6$1& zh!+3q+HX4mOFAM~J4S-4LF{JIA5^)=q5QY!Ru^BlKEm#$iyC>aSG{2P>xmfZ1l}JG z4R!8_<+8$=P-aGA)^tc-foHQTkI~O!@$-)#6PiM$@X9btpkDuncl3VL(dsx;u7!cX zTc{_@NQPg>n@;E)+^>4QYHTv2?X|{py&ZPK`F~G+a9TJ5Zpns`UffCOAnw`bW8)=N zVj<>OQjYpI#*A{2LqpRNFcgJHG44zKOg0*z4lT-bhOAwLFaFs+5w7|>tQPC+?X)n_ z1}CreEt|2O8NUs^^(0hzByID?8%|otmFZ*07LvK>k~OubB@KN{f$|r1*ixa;_a{D} z6aa;xiyPt)HaO3c$i(1)iC!ezZU)@_7T%+)YtYJN4Ot69Gx zZS&E#Jp#Ys2r{#?VoST*wzibk<1QM58<79k51{)Hc+Gp`3umhzbU~9#{^;9cabq%`S`<{nrC&LNu+`AndB4RJQp^u&E&{S%?LiHXLLX)Pz_p)01PZ}h zaz~AA&9fDHi&Oe@vQEyf>mI;6rAf)$n5wz+j|3w1YA8|D-oDM3s-nyE6I%gkJ|HsT z3e_b<0}h*!jmvSbPeQ`N>z=K$1)st8OZmZCQ28(rxKRpfZA}`R_%BC)XF2c&o%(`q z0PH4XaNb$mzfk5TS7l2E$Mm$iC?x&zdYWM3B2@Biri9p`68|nH_>4c|4k1?_*9_1L zrA`-DF6^9q2QiOQ>7c>kFMZ^jscL&+NP$X?j=j7yO_TxwA`lXpG``^m*%cm*hc7lq zGbQ~$x$Up;JrEO{tN1H%^}9zNV~m3o8$|3JYcoU$e)rV(F83SQj@Tu7_QFsZ-M`BC z9U|uEz`M=(ny>wsm_RHlK{HhA7iKpL2NH!-4V4IXLEOBsjwb`p-|IjAKYJ|r2l2ES z2s1>UQKwEn#?%wlHDPeYBE&^^uwzPu*(fFV9VBPAWJIm-RX6eBm4-02FATKv?LqehD(%kOTQlfup(^uG2s~_ZH=yJ#4ZrQk0L!Ci50jy zosGvu9=+~nw5YpeFAV-^aqi}oyW4j@igKX9^ct+X5LI!^HGbt8j1i;Yy}5UTh!fsK;XHejiY z9U9aUfR$YI;8?3CV`PI{*g;01L|5X?qjwv-lzYYVPG+#7iMf^KU|8lY&b#^j=Mf^8 z7S?l5X}mCZNlMcXD@}Msz4pF=2NZ${=x6M3Bf}RiHmi(ky@S? z)$hW>1n7z}ixbc^K=btO0Reij-5U?`S`r};esQnm`!{?ZZH5ni$$j@1U*mm<7eJ_B z9G)P9pA%rS@rVXx^vkq{k=Ol5L2;(h8tk4VX7Z zy*^Cufal>h6;;XCr{KbR#Ch`X$)AaL+^Qq@&Be#>5!umO94;>pspPRHq7=u9;_tNUnYZo6x8KkI+_K^VsO94>&+(xZeG` z8r|J%Fy|mWW}h(6JX(;tS?aj*ikP$_*ZvkK5|ww=oY&(wF|p0Di^WgcDmwcMR4$Td zFC-OwBH3ol*d zB6JcgENHSMQX7wKQ>hTTtWWPg$?>Ci$q*}ijRm6UQQp6{R$+!gFV$>Iq?@?`iGBkA z-C4ge|0At($yrBhU;g{|O9}B$-kWvl)tMe7?zOBK$zH4+y_Yz-bKA}LK150RE#JDm zeCdC|_mA~OYx!r@2sERqneqGf`UI~3UlspfXT&AJL+42sl zXDfYTU0pS8?3GmjDFv8ZQtXQIat6G8_Dc*Q z9*nx|R}tJYJu@>iOo>YWxzXiHITrcyCZ=&ycm-K=w{Hq{Nop*oo+XSYCJkY@J~;#3 zMI>Pa{QJ+J_sG@7g1oL3r%A7tRN8x`J>D<0QXFZj z>=T#nm1vBf^O8??IN#_1;dON{7-Ygt_?+?z>+#JL9kD|<99s-`ohi#UkR>dVM zqGoJ(w92PW&-qVf!c_I!!{}{>Y$!BMDe6(aF{rph{cC-1?U(K`nA9!4=nlqUDc{BQ z#QKGw>VSscb3~~U{DMp4 zc^uP;o2!JQFvR`h^gnbvVIgR4#>@HUoYK6osc(6!Ma_u?GhdU{EkcI1P^Cp_NF`CO z++E1|p{eu@QywJp35T}C)P8zOUmJRPn)!RAYKMxxRPoQbd!sguRV7zr^XyI?_e}Nb z*3VqQ${0HA3>MW8TM4Bs#y*m}8kzaIEtAfAcTGVeO!Ot;pGld>*OHZD6LWJ#KN;8b zkYkUJl{?zp-LzQw5!tzWZvLzK`uef1di|eugx`@Cu78IOjOQyPWr`ZUL?!PW$p=C2 zlWAoP&P~)7moKCn*n&UKp2YA~;bxOGSGRKwUjK`oJ}yilxxHYsnLG07k2%d;g==`y zX6D4)|c^>(0S*kCyx3!j* zz5vg9p*YvIoJx5Vha>e4wP;@ufyDeNdQT-BTwNAT&tR@d>jWDU9dbVnfg)n^TKMk) zPbkToH50WX4)hJT$J|93HC~ol$w<_Za+tCPCoP&By<7~hBh63HBEbddYqhP#Uw_(S zR?lC3o;>3t^zGuj*1B;IEoK@PgqdnqKji&isNb|uswnE^1Yqe3r$3O11y{4C?CRvN zR&~ui?#oWRo#>UKK)KuU2J6iaP{IvGvgNaSoAz`bWS;2_iR29vAk}2!ni`rf^%gh} zGHJHsyJP)R{Km;Ita)N0j|+@0NzF(6!!B3#7}H3|^023APn`XUGMgx)P@Cg4<*=bF zi%cj%^;?+`VAFa9JK5)hRW#k<9$_*zoZ2 zwY3?b(P&?r{zq9yrjoA2VpWq7bjzz30$7Jr=RB^QZ`&&~5K>Z66<8P02+hR0-;Z5Y z8BY=n^Oc%U2Et4m-r*yDUi&($iXvR91DVo}0`q3^!VegwE2g~ZSghLj?sZ44-)9K> zEY#!s{fmWn7Jo&j1^>6r>8#;$L1il%W`^8v(t@`=EqA6aRNPx>zKsfK5Zxk9@v_W@ z$=7<{FB&=joSO(~Xcy)u6-!@#k}Zk@^2RHJ1|u?^tGLef-%nK}$e+tMH7n=c5D{Tc zQ|3OYnFFOCNoVZTWM82uV$-A%0D+>g1}XuupfXHu+)h%JCmunc6gtgQP1Bov23Rq^+(%Jz~Y!b$-4W; z#a-EO{KTMbzS==IwSlC#ZN6xdbVj5UCfWA0 zkjd9l*H1#lACeI53v;KBjE#@KwZ1$isFbfyfeUK1CyAOO1N1sTBZ)B$QhFvMyW%YC zyVcng@;MNfM%^9`PI?Ndq=7YCQ+%xwi$Jt6E^>r6V zAG2Fo6u+lIk$W)y(^uZAuDUwl;_=4`I^@2npf3L1tGRJ`^w0|GtUKp7565OiUAc$| z&{^aBzcvR32A-UF1QjcpH^4@CpN-{H{Qx6m*vb~mqO1bb;4 zO*zw9H&^2cM@B`=)5MsQSLQZ0^^3dq!Yw#tOBloG)qBbk}7!jmusUw*E^&Sx^9S(LoN7TmmR1_qjFvhu#L9y~rLt6!D0p7Ya z-d@r;uF_E>WcMO_S6#(SI7k6C#hH4jnbO8kkU)Q#=5^Mb%TNZNn84VTQf94`>bvCg z?>KUu$(qrodHnC`@?`cf`lvXL*vSX!q~{D_LM-;-@Ae`JEn3u4xWKeO79$6Md@`h%$yoMUeHqr#=cx(e z{pCog_&6U|ocEZ0?xrx85%tZ4i8(&8{Jzn$-@*FVh)U7qp@d2pjE0AW=^6%$-QUfu z9sneawcs7P(YIl^6JpMT@wWWuLaP^@r5O($^+rEEcZGlg*n?@9YGC;kXl?CYw}%XZ#>EEL{ai+bq$TyzDcvr z&s)o{3o4&gVUm!B!G1%B_3PguQ9b!bCmo;;b-CGeIc<^LF6_9-?ihMQRPcR2Oq3;A zxv?xANtGu>QUCxt(cz=_4`^Lqiqaz6;eWpYPThn*q5)ykl|5o-_dO%G* z?$Ef%u8~{#&4sV+mtNJcN;bb9PFqoeyEHr-kgBu9+HX=`Rh3NhuK(Ocq6y>TFEAP& zH$-jFPo_Y`Wi#v#KIF?Bd^+p+cTGvLPZlAP#l!mM(Z6GjfA#l)yWsod%=h+76?$_* z>``D2Ri$Fq?cXIxhlD{$cS@ItAczP&N=vtNN(qRhG?I#RNJ>cyC>_$>HN1QN?`N(Hn3*%@?B8B% z-Ag^>=K&C&mVq!K@U|CF_P^YiA)Pn0i`dz%e@SkK1@L9Ft4KeH#u*wKV(kDJ;eCV_ zm_{3RJSQ4vgWo(&a%A#ZT_rxvE*;x^&J5h?%&TRNn{%m~)u5!lZ2qdYxwGgwpm7BS z{`@(hi@7lGXmM|aMq)GMy8p-SI#pCm&_gfW9A)&QuPwVMf`PvNi;6m7I&Zm7yOLGI zSg+n)IGQ02k{LXfi6YRoDzGje8IK~X)E*8>nJA5rEsMGw@ZTKp16Ed*v81bX>$6fU z{dJz%1>2Z-{v4S17BbJmGbi_voQsC$%?8t>9Eu{R&eqn}wzjsxtNy_)cb|Ky-lJ)= z(DhaPgL%Gmf^y>AfGu-Sm6s)cfg2*!rfG~J__x}9(6Ekr$cXN94 zSc}Ru81DJkQa6J)huH)^g@*4Zk(b_*w?m}WnUbYVjLv$X_20P#tr_DMvL z2#+6XU^NEj22_9iZQlM%`9wIk*Y8k$daJeRGC?23O$C5J-j9V6ym^@V-0g z^$r|XFPnESk!^Cms38#+LUJzcvmrdR6ru{j3LND_lTLMC3b7Jz?|c}rQhAz4g)sR0 zu25!}dAvvGp;qS)wKgq(5$7*JLz?ACrHt?-`@(h+M%}u%vFF;082iB+ZonWA!1AaN zlX_gmjr0_4z{97#VXtcEi`vT+>wC({D1nHfZ)UrJsN{W7)R`1k27a*O_L<zkZ!nb4&E|gSUd-TCS+aUFqWEwn-H=&l>Z8 z%m;8KqQA=?G&_=^Hh647X1Lf9j|%FjV|-6ZmMYpErw)tCA3tQUm>bsIVxBUG5ju>^ zs@N=|1}vLS`ND6()x)B#HjWOGMMM(%|6O1>>E5g>rESIRXr!>X%^k$*+h1R?o+lNB+dcp-C^ zz=*>{;6%wC#PcB1G95#(d940`K~?(=v?%{+9bhAfvo1mJBUk%j99Zf#^U39vA>LuE zUBPLVF>%52fWz2(|3113>|OWD0^v2j%uSnjR$^a&&INT(_UyMUuOE}3)R6ve`zrry z6p!@mhU&$h6sc1td)&gU<59d-R9gb(s-GWo{aod+X*7zV-d0qUi-0Wcoh|!Lo9i!> zU6)5Glxt-UBK_A>w^T^!X=!sWf~x4w)OA81gdz~Wjmenu`S0%Cy7kRYMP5el$X5J& zHn>C-Fp5wW1zG@&bb=;;!8I?~LH8%@7Li|D8dErG?UF{`|?2CLR%3sEbo( zO&g#Wbz-H(hmTQRUEMvx&SDDt4$7x5*zrW~E=!5qoox|*a0>xF8YFTU3nViO9^6Lp z1iv^4^dj;4!5fiKngC~l{e2_C9?E~WB)!k}E-pNI$v=nLEdVp!jX zM{TqR2ctFejA<(P%9=tc6Nknp#vH6w#d2SkPbv$vm=fY^JZ9&r8;>YQUkjzFvxC3p z0W}>JRccBKEGkoOdenWc_PZB+vq_-41U#Oz+fX5(RBE8wc&@zNf4fo-N)SEgVNJ}5 zwZ@bZKok##17W{I;idA(?j;dnPqv?n?s{QpOFJwppFMjSY=n9GuuZc6s!8|MtU%30-T^8{%5Xifd+wPi^|J#Qj`o4-GF|2!&%AxY{M{nL=Z& zoxQ*1Lv2-j_8zp68b1So#GeiQ!kx*=7Zpqk&ETetjD#0bIdRPIIUH$?Ya&6}=OdCh zpO?oWhzB=Lc%>QzGs`nZydic|ZjsNkJC_`>Kk?ta`-2QJewB_DUhwU@|LPYA(Gr~B z-1XWPke^GXk;$`Xk6DSYxIxw>4u?q?f}LPKF{2v1Gq1o*^bOyXb^=ew_kWR&D0Y%^ zBVIm!ey|&TlJNSV4HXs;d{2f};!kO54dbT|;cSa|6%p{mVRP*;_$5utt*U5tR+Pwj#YlJtb;0Krl|KQpq95*vVnG#mq3qS*I|?-nhJMF}2?+`DB7!@;21t;m z55T@0M<2|cHlIS7uQD^MRFWhN0CR^DbBANPnvN3ZaV-ZtEwT?Pc+xi=@8E5|jO<*D zy`GE}OsqYN5RjqVhgvj2 z-?BeO2&{74+nI3PA=_U)=9+z~c%sMZ|UL=(v{w>>*HZty7d(U@bWKF*Ea(WgUY3Ytu{?KB9r8el*MDzf3W& zgLt?Q&hO40+(nfD6Af~p~zgvjB2F^hmSo?h3wDpo7ZqxtO{Dli;$7KVp z2@NWj%WsZpXlT6M;TmpP^=eky`C@m~;CH%fjh=pv?2sdnJj)t9X1JW}UVEco-LODD z%=66XbCKAVMU8gmd*kaa;pVs^&L-_kSnMG;%q&hrsaTnaqk>olsThVXXB5cD(1|)B zN3x1b-n*4_W-?wVu()Y~c9%i*tPTuc!*4&N8TZ=Zt%Z$d%|$c%J2-$X*!=j0lAIu~ zM9n;bBh3RK8>u~1DJb;_%UhV25sEg$ko}7sR@Kce%)d^_Q=fe5RgO4to8y*5?8mkX z=ioyD3~l|V$p3eeNO>Hv68JzUM(p9kJW0c7ru5G+n5Q+br@^wzdJy>`uUnv9?JXvb z!EV+I<|lb~xq?v-n1tl+FDGl&MrNFWcy<`F8yvOS%M4Q_WV58a&nmp0A|N@7J>&^D ztmd;${)@iy#SurZ<{7)2jdDcse{{fRV4$ZD8BwA=K?cC%EY$Kwcue=P-B9Fyay|=u zpN8D@JFm9lJ?(4&kO?xGf<$Yw630!A-<52=oQ0c7tQ6wx(fh(>dJ^;a3wzlG?uDGyLKtefL_(>tI>My~&&Q9R>mY6(oh5mQ06n=xtf_ zQ{e-E~f_n zIfU@d0MMJI1`SRt*tbz7cQ=hmY{VU5WsS4%Zh}P<^aJ){5O9h(fOAZp zaVfL+5w_Vv=Zc1mXX~a8cM>KdWbEaC|EU>x^C7lgNu@zX<=k7G{st7NsLAXgr&-Jf zF2@u3I%(G3cE8>Hc4DN0pXs^5WvN>e&y!UHjn-J!9z%v+;klD8N%E1IszLi=fijg9=eM=o7>H*>nPm29esS!y!cZz%azk<*H;-=M>EJ zLET%9ng=so?>t6ACR}~`c3QCC!x~dcIyyG|ZD_PYi3|*G59!(iTqH9w@;?q=UmeU` ztQ&&4#W@qEo8}^u^v@RmsfNkVdghA_@|IL>|A74aM$% z0=Gu7ana>8Nui-Em5Ox>wy}+8V64dXx@W+|=tSOo!J|Q6+usn@F@?Vvl8^Rj)3q+-I-%x-#r9Arsq} zLPLDPd>ciM>p->I_&D}IiiG%*`c^NnfB@0k&rixC=YWEVj+v8TUl|c$_dGZ8Ifep( zr$WO_{#Y4vAJ$mNNXFnDd1$D#egNqg%u&PrC0OXV#IpWU%Ae_J*0HBtolUt$%dA1N$KL!!=`9;Ixr%3(vgXsWoVdZVa45g?j4O$m_`lJNpvGJ)iy*KS&d2^e#8 za|A0TF5xxuG~wgc~CUh3J(^WczKL z{dcq}UzDPVtot-qJMqxr6PqJ^AGVawRFAH=9G{kbuko$}!E>Pi#?>`&X(br89Of44r8hdyKXh zP&l9DcCCFUMzj1$io?W>p$kipY%jvs{@5KpKc|nAowS@pCWyFL6$|eW6X+}WC zeShyKJ>p{sUb;oZ^G;!{~7uS~O!`-vV5@?W9H%>uq8)y zr!61I_6^lKb|q!4CPRMAd_BDiO_QL zh^XM*vlpT5qQkfh{LZh*L5bVoZ-W+Mk7>;!$2;2cCri{t@IMKhj{dDqP<}`BBRX@W zsIG8`>r7%=eY#|?C?}UKJB*Eu+gwi7YYKpvE6cQun@p&Sg6B9GE{{TlJrO|D+AfOi zTqw&TBqTI+4eYw}^vP2FZt1Sqo$Thx`t9=+7SztNFK#PHE_r62GBc`fWrm@}Z(!oc zBnF*e_!{juu<)EI%QD9;&yBn#6k*NR7A)*lhKu(7hC{CMo2=lRWFYx#i33XEwa{i) z-jQvr=er?H_mu`VH7=UsBuI0CkZ7N~7WaywwsA6MFYV2nH|My5m9Di(S~cF7ekMGU zMGHA^5A4TJPJ}E~?}TgzdKFNlJXeo`-`5_%Q(@jV3CrlL^WC?CMU0JE>QaMsWbBl< zW##284QkCC>kKVHA967xS>iCqiM2jC^e&jJyoEJT(UXs;%n8TCfsBGL5MP&v1*UAX zx?gH73kXuWV*LMAy`m{(6=n3=BmP-MuQ*Nt8pn@~4Q>>{w5pc6Q?zjK_DP74M>0{2 z5WxBGkbv(O=;>QyW;p2Y1hSkdOTJUHU%`n;GaR*Q*c!~}%U(fNrni;EiN#%fD-clL z2q)2XU#KXm(=|A^`U;(l=1JNsjQS$7-#XPf1L%pmNm{?Mup$oXhOPI^I`_Zc5jlv< z)Jwfh_Hz}%-K9RbCl{6M%&WB!W0_H5o9MuHcEo|L|A3mULxZ=_@>SeHkYR!<`=IwJ zrD+8SF?)Eozbgy(8#2}1DdOo^TlWgJM~807X^Z_oX`L*?KSbV&%wX|nFDIOh`QQfB z5J5Stv$O7ZznTYR^ikmWn41IVV#Qx3E#fSG`vzuphY)LTh>JtNw8C^k5=&+sl)d$Q z0hZCH?mOQ&x!)OiW7WP_IGF1GTJ9p}NJOkAJy>!ZH{c(W;4|3HGmUVx$!kj+n?QM^ z;E?Sti|Cwp?%%dPX55?Q#4Qf+&q7`48~DklEOgJoLfe(Ul`~7}bN$c_SeRB-=A7>w zvwjWs^!SK1!zhCNxb=Qm(|m8oxNWr-=b8MSee00{kBGD~&!_W6tlNiGjl1x^^;)SZ z?7oGSN8-m^k2Bhsa-M-r_cnu0VfS042da8xX~e(O$@*P=;w|TuvAX99M`$IZhq)*J z{2|W1YlScTGIQoRfpIx*4N*QBWi!)!1W}G2oMI>)XIxreb%z8gF%x2HW%s;%KdB3v z9UOotUnUiB9{Bbje#)v^lKf0bPk%!C+(NR}Tp(TJ70@h|X_hGsqYU=SYzx6j-VBZ$ zdK_yJTEz_Z9N2w35I0aTk~gdIbtiZz5;SQV??>%{$tHd{9EEhs@YTYmcMWxHkYU0G^Iouv>#8~-&#y+u$FS)fx z?*3`{J`qs@DJnZt(l$@wo;Vmv%h>eBd`*B~HPRU}?=+0gH`P)a%$vX@s1- zx8^;;hsQ?L{de*ND$xX067Ss^CsSd}za>!{AsN4Y$lRs@mb zEW{rLJ#iXn=^CFzD*bMJsrcE-#c>=H4o0|Nug^fpoBpUD;<15AV0mCYg6A;GTTEhq zla(nOg1|ryCQ3;sbR1dwX8Q-!lf%QNq?0Uj5*&|kr8<-eQCOGim%VndWH?yWQbH^L zhU02u+#gNh*1P(R$FmV~`G~j{(u6twL9**)c3+5E=xAw=;<&@!e)t-=0DJDA=|3;{ zxVW1joi1M#L`7_fj{UVH+#K;`VsoPGneJIc?5^yBPMFpjH}gBEb^qxx%|vp&FR$)e zmr@*kB;|r`SIK6^s_4`vP)+il{~;=lRAPV}e66b2GZ+(EzJC`I6Yf;f6tc>d7;W2ka37i9FxzI(fJ|lr!-{X5e_&E=+EMp93py$*aBg1F^`n z#V5B$=&k1AysJ@wJRkZISUCbJ0V#dlBq6o?TBil1FOq)m{!GSm0r$Omnc<$2oC4ln zu+&>v1olJrx!!)RS&y6TU0yzU+Y{i=8NHc2k&5ms1MtZhmIQ*E584%hZk!rzoP>eMP=$o|qjIZ3JQ(Nsoo2VCK_&u14cksoY>u;e2m z@`lv?L9DF57Eka92)vB>jG3%<=jZ2PPo&?lG?Xp3#c_wEDw5b=KF9S@dOjtJVrbfe z|Kcwwti}ty4%kh~|KfcF?B1o+Et+;5x~8hnxFKl)H(Li|UYVJhyKfniYP;uqg?hse zV%!>+KspU@;IKjG z;;U?lmQ$~mg5rAYUG3tFt*tF6OVy4#GPzlTCA+*`;l4K`@#)$A5?E!ym>p#gw6ko6 z3nscjqk}|CV*F5KC#Lf&Q_-}6W?1C!MSbywShwF*x1Wjr>+5dAU>iu88}wLI{tx@+ z>iWUU(T?WyeQp`78hP1DnQkjX93`2jzE znp0Ri)nkEjw!nZezY=Kdd;GgspY0D)1<+tm;PZ%4Qv{LaBJ<|ZFaNLGvx*Z}nf~iy zlB;nz=L5ccJC6+5cV<_eX3LL@bi4lj-bBdHTT@TiR?l6O&K<-RBUvR73{kI+7`~n! z>8wFh?^FB?6bj90_~VlOxl)JsrP^^u6mC{pu99JIp1FCmLFPks$yC|611nua?$;zs$H2z0xwsyhjy5BV{cp!Z-Ly>zY!q00>1z$cn ze7xEP`s3hO66^Uj>{a#iR%^8&9gsVU5Z(d2KL|&}lJT+N40hLdF%+EXIF` z)bBcPL!mP0&z%50nEoZF|HlM$WODGKV_IeH66u{<3uaXvy!KyWi$WHYqcj5g`i zXCGN#1oFzv2VN{o&q#~bpSwTkD84lA@t-%MEh$LTr5^(30=7nG zGy99mtOxnRO+6%h(1DWs>~w=xA`c32CvGmxyz+KvB|MKnxtk9Ss^*;b?%wnO=y#?@ z!4nY#e+h!=va!6}-qCR%{MnmikIp{SG%7r#dj9zW+H~u_eH-KHzQFLE$H2s4mER7D zx_s~sP3`i0%k*>Vy2pRVrGq@1cH(QxJqceNa~(v&;(ILllGXBb?A_aGYMJc+ycUu= zts4Y$;cGiPc49134DJQn>PN!DZi^k^AR4$U^!#)(lQ%0C{D|sAhO}U|7XC0^3d;L~ zyj{NCniRa5y-(?lT=>yEr%7zigY=_oP)e?Af{}YqQYQ4ZWi-}eny$(vXdyM zq}y%Mcc7q+ncng!M6VyWeFLyReEeeXlwuOj{7gOZ*xC@`IhOZK=S*=Wo`Ofo?k6_H ztht|l$1ebGx$?H%$XBK5xIB}D?t$n9eAUCGf1f{$Zu6bTB03zDxgpsC(ak{K3ESEw z`8Hqmo~LL^*(OC(I}KUBqf#Stg-!#OLrE|*>T(Vo#<@w%+X?G2rP#zDYBAZp5GoZ5 zrHa|!-UjT2sg64*>0;74c@p`~TW94Ldfwb|%6sjm2BLv6W9@c^r?N$Q%mfSUr-ZSx z&DGTk+${tt}dhmd5qElxM@7R}P(E$MR0`3n{u z^@PGZxzCHK^@MAUmK0pP_>x&Zt$+6~?uX$Vb#G|sJ;Bs}FxBVjK!xFtN3{45hUs11 zc5iYDuFINw4SfKyCOdUf!7|fW>vNfF?TeE@pVJwy55QGz#%t#FOOhtP?KmMDJ=eEU zSyzYklvM3qPkB&)>9gE%$NNmU%($4rvb@foxSz$IV!OIoeP)k+O)F`Pfi3j!3V_sz z&;NP`TmK|a^+jup&E|>wepI#0Dvp9OBR%eM2-m1PxN(-9d(%@he}Bp8 zsE_f&+4)e254)W{2zmOqc4>&ur2F^KFfh?v|5rrQJIj0F!$(M+AnxwpzkikOp_^my z%*}Vzjd;PcggcPL)I-Pmd5Nr zDr#!azkg>H<7VI<_T&rIW3;tMb1jZ~?3bS;eJ+rX7NImYk+exNl$F2RCr@V&$a7G@ zrYEmxNpy7kWf(Jh9oenge>c}4;U#crGS>{-7cbLc2hZ-uxV5r>Yig2!%9**j8>9}? z*Vni2?hWqd=g%2a)j^TcT$!e_oCOZxvHrtIzzX7LLoS{#}ctGh3M`lZ+sw` z&DhU&&NjpY5!cxp#ObcP1T<8~-nf^H_pUf;WzFV_EwX2i<-^TMvBIF_8lLV8F%%To z!AKpaK;K#akF zqttnV)VhMz1@NU9#9Voa!v(^QuKX@EZ;B?4?Y;i~bx0JHb}~NMpye93d#Ivq`1T#I z>ogr_89cH5ASCa}#(A@>iD2apnoOPUev8_sRR(E=aQQ`4hBIiH0vlRb_maa_PB9yC zIEzwDBRmDAf8^h*49S|fZu$x6v?GK$lB z2G&jlvX#Vv2AQu@WcBs@5~k~ISFyB#st*_#7*EnFjb3|tULao*4oG+49&>qgU5*%U zX^Sns)U|$TW%UoKmFP{)JfFnN=%ht&$04lY`CCizzCZChr|;1#hC7WrKVC1{R$mOs z5fFLAs<(@>-d~0Q@QusP4LCy9V3q?tm^!-tf*#{3FZt#69OBJSb&DDni;;2X=#_5H|tVyw>~@l+zHxJ zEH%(IebF$3$k;un|CoJCz=Uv3mO$c&&`HXi5|o{VP=*gU3eR%ceJ0#|lG8qH5LmD# zzJV4f1YAWTlc=OS*YBjxP#+>r*lE=^H(eeVquap`xnTl4+< zgFC!@HyC&C-YwEcUUtjLYX+<_w4znDwQKm_MzVaeM6cj)w17*-{%ECJ`{h7T(Z?{*?IjmQJVK!pHI%>)ZW3_Ds}JXV zOdK9mMQTwwiL~3X#>2(JQZGr152vqL2})cYitw<+Sg2-Pq}a$KQ%*_Hg7@kSzQ((2 zuFj}T@{w@xCCy_je5%zCrw29D17eZnFx`!ZJKXEsPgX}k<-~JVcjPI$FIGb)lFo{w zp{{;5`Ad5Qsg8wL0J$&JEK};b%l-;|00F~RxPHUL@g3^xwf#26Z>}msZCFE z{L!poYwyb%zXreR?&ks`LPGg<3-@*EySCXLSD0QF=mo-8c52Y~B!ndm?sSX%2wB-f zyuU2Vhv!IR8#x74vDm4evBter^*o)`U+ITe2C6eL@aP6?gO`_=l~o9hPR#qkooU$P zwd~=vRDA#bZ)B}*O-N-e4Qan~s;rNCy2HZG&R%BP)O(Cnr(K$8%JM%Oa5=ySTT#=- zggdC~Fyfv3K@kZ=+_8Td)QO{Q`z=h@P>ETxFA9F~4zfbrqt;2WWsEw*vMZ^NtK!GT~x+a0`+! zy@&Z6Qv*{Tw%VN*J(ghTN>5=H3Do=Sk6vO_qy#Z0YVaP05h;Wa+COf4uumM;C$IJG z?;DG^gkSY;Lqq0=zL%Da5jKRO^SW!QGULk85I?y*+5XHZ_=SsgH(syQxUJe4?<;3J zQMmm4Clx>p{4x+c01?fR+B|sqkLglOun~g%rPz^9u69sZ;qQX z?QXh~S~Niv+g<*w0oEic`A>0kK5*$K9dzbvcv1>FiJ8JWa~kXObdu?|k}W}Kd+!_nUvs5| zU)G9%!-;tZpFwhK1h=F7^Tc)dWVXbYDFE!zD_0tkPEmMt!OAYVZ((%QgcyT*d$_f7 z@XkA#lYWRgRp!F}ly*1NsC+XBAna1suP5kS`H;V%iIK%!>0Tt((Mn2mul zv!4BvO4(5PEd-NN)m58`6ryys znL&2zd%dAPpHTG>MULxeRt4=WizU5nhn}@w-U4zO86VZm=hN!}vf2LfiwOmP)v!69 zW*KIexi+K^uBKXDeJ~mMTTQTMt%!Hbo31fh*(4w!P*GithIa$T74XWdZlW2-WQCWg zeyySTnOK`!NTNOrnfLh%RDI%}gXBj?t3LctFwU2~=FP)SH*D0M45G}jG*0k`^NdQ}#%)dSQacgLGVB0va-z-WM?>7s! z2VZTE%<`M=Ej@AJBMUhA_>=urXJxtKXYJ&F`o$s)?#UoFV?!CG-v0aEm+H?=NB!uj zaS;`Nx8hr6XD0Rk|p=X$L%66GC3>_E0CXkx{DwlY~%Sef9_xkl- zOfBYvFP}O-Wff{R)cUa!bCF_m`l<@bS8cgG%3a|qlH--j#o-{vQm?pDA=>zOzxWon z;jOMdElyTuXTisgGI=@+9G`0Kwgn>MnYH(Ms8}SbA}Q5gW>CC|sigxmAih_f$(XSU zSwGJT^NZ|QdFExVs*guMT1pPj#SbFNmdWCQ@DTpAB*i?*gbZ1tjI9%s_9)!zwr-vt z8aLZzD8<3WPU(>T^nc>F$r>MS@kDLCS-#V58rhV&3Q2Bn`5Ccy_4sWJe>9gG(sHx# z$Apr(vHi492gdK_ltHcCfi@PUZmyiK8h3@}w)w-9x(L2)sbG^BtJ7`QJKVSb(Zstb z-1)}x;Ehq#x9L~j)e3UoBUfZkSPaNx#J2m-FplK>HZaAl1a8+-{eAs7_num6x41UA z08XV(i7X{+V`>oy1Pr0m|3S_q$SJ0d?1jh~b})+QVibkvLq(F`pSu-o1g4P&IPtFz z!KfB|aW%{FCs;J@^fDP1smd$EzNV;~_i{s1vPh{TF=G;=UN4Xk4dW1_5PC4B$bMyZ z4P#_Zk+ZF)))O^ywuyD$R6&I$_MP!9zD2c1w+y7&u=esPW1;-z`{XlgAI!jrItq#c zc`7G7^Z&A6qX3*zla}J(lTnKDvs$K2Ozm}-hfBf9Ss)DmImqYLtWTDa;gFG)J!mCY z6F`s6&!RkFuumMY@}WlkA!Un>t#U6_9`ge)r^j%Tg&;@6zFH01v?`H_Kr83G(zbc7 zyU&?r#W6k}UXRb%vl02_6!mP+CVafYoC%l8%cnVY%Euor3n{ePE$zu~Y|1wu=0SOE zo(>fyC1X||WIFaO4DL%@;Z0UTa@yAHLVyIVk)^C={HxQvEZy>s#@Z;EC z>fx4v1Vroa`Po*3#x6@@b()}|X7m}ey8`pf`bqJ$u(-H7E-_TjggP#u4JU>L$?sd8 zGR{ZrN%`iO?9otT;-WK%@8$`%3$vT>6g3YMt)b61-_k>=sH+QC?{Pe9bLUsLC=`~b zW-Na``9Z6%;-X{yBrqrBJ*vDu-y{4l$GP?Kl3_Bz&`4es4}iKBljY_ z3kshG-%(nVbB(XOpNKQ&#K{}NJijne`PtH(#N%HK=}XPiKaM;@=CxoSs&Vrn8V&A< z-G2x-rjjzU%pR^--BJVa=h;U6cYfk;Co?cQZO~HJvgr8Uc=0Km21sM}JYFiKf!m+* z#kJ4F#bHDA^EVW1dD0uad)lu-*tJEy|CqI{sVtc*J?-;IAv@#YsQ%&J%c5jToEt;e z(MjlkMOU+-tUw=rZcrJBPL{mp>?}@m5yC9cD7MOi_uLPHGs_X6*mp%5N#Z>aBg;kO zzr|3!AliW=;~?n0BsW5{k3LC6^iM$dSmH)To?r0p7`BhOyHnCC_h-`8vKTgt7oG}1 zmvSv_QvP_9ZsLpl$6w+9`aQ6+^0MFk+&e>sO+kT(w?q2!?}n$0w=Of5V~e(~wv}D} z?|6(!v~bNd->F0We|_0Yd~p?s)CCI zWtk9QWG$`Fj{N?Ihk#ErU3{V;B7oWhnFH^2IQ zzI*82?(XBec8LA$lS*V_f8uYKwvIBdh(c*ke$!ynQ>6#5l;V3slcm$Uc9g=18s1+q ziTyGsa6o&$JCuCjUZ_c$)0GTqcCi@+1%ZltXJ=txId20o#vT<1{cA zY{0zdnl@NXvuY?c?%Lou!5Xsj4U}y)cUvg!j19tgXXt;w*N2l_OE|LL&}+JQq7uf|2KOGo_mriu>hZJ1OHwCii#J6P@)eA=DznBZ`%yu8~=#MM3%Qtt>Z=J-8 zy;x|=DFN*YqCasKMCNf^3%y60$3#gSH#6y~yQm@Pw}Dh0sa-H}Ot`m+GSFi>(a?E& z-CHpzr|*janN$~UEODP^*nbB$EsesxW$Xq@r8?B;Z@a5+_72k=E%%)dEIU@R?&_5! zosekc$FN0d9V+z@a5udc*rEoZG($qKWSjvO(9^TCUFh%jPTMfQGrfpnRX#xJ`LXSl zf%+pci|Chj&jX!+u%hFd?Q@pQL5z1ltRJYxGv|ngTHH%btSf72@q9g+%g!_Za2%#WR4cm%wBKyYe8s@4hx>}Cn7f{)3U74g;w|TLSLo+2CVV`;ildW$ zH>}fUruV+ddkl8u;i!B}^8vY~+cwMO4RIIdN^-319ht;9D}0_|Wh!dPQxMTO7r5y; z@&aebS}+=5TsK(D8Wa6SY8u+ZmDvM$I$ZPx5B_MXX2D?|-1)D_y?fC=&WwZRRZ+{p zz}jo%mgm{%@F7LI#_Hde>%S^`Z`njcqO>9)dIXD$@l2LH3TTq5@$ReHOBEn{z@r@o zg{hzfI@{V}6G4OpNf?1DMK=eW` zu6U~&2y^MZ_hbUoNhkfWbV&=5m^#Gu<@xT|*cg<$7RJ9RJJY79L3syi955Cvd1_u^vG@v#hyviOGOdJP=`M=FSu?`D5)d;M#=2 zIJxC&rI*JCu=yO^BQb74E!@u@^@6=8KrSlTlXmd683}mMOQg4Q& z8G{0Nr<)Fv%E#uLLDGPhRLR#EU~qkG?@6MvZTIbZ8|6{_q?Fl7Rr0wKA-wWu+(vw< zf4h4bXNqR*q|WBwfqcJA+u+B1ik`l@ZSN=6Y(jeXv2mv1Jat4m%a4W+?p^8lpHfoh z(Im8kC7X%j+tLR9!Mg$b31&X>o+{;WWp`NGRD~p5J|r|0i4T9V+Nyql;@|7xyMSZn4lmv7{zdCy&UZml zVI)MIOt;LiotX^tj_*E&pLU{rO@!iSM}X6W(tG}lp53P{yt!_S8#yp8pcOlK3`Q_E8tKv|_GX$b+^!ZT_`sb@VuEG?&~- zL(63Yr3rk!I1ZSI!>?e+^TqT#G^0m$3InCwB_=;Wr$3=*`R3dYkvZ+><@Hy0q?(4b zVCi1hCaf+-_Vy~&7}hWD#4t!9QU|?5tmY~X?a7K&ON3y9ceCPmZU!AG07X%R@(Sq=T1^zH+J33M z&nAetRgp^0o^j|(0qR>uFip5$1MsBB651a4L;~HbL7?O$6$)Q0y031{%U$&51ouc;&(k7Rns0T;~!6G-U|F+h~T@oEW zOia0sA$|#YEs^(6F%9Ihes#A!e&ysG#N>okE84HYtPJ?U6!ab*Es1%jIsn&&1?I|_ z`*&=}wP+{kW2K)_DWd~Z74~c3yvG(}dQ9?eWowH!h+F45#6YV5oA@adF3$|(fKCx4 zWEjaHn9#B0sPJgPd$KZ<%x>YlqQ0KHOoz%$n*b~anx90n#qY%RAI;!jwL7k*Y?r`? zWEyJJA5BNBL^%DpSKI23mSRl<_75=9W*-LS@AZPEUQ++>$?n{suWZwIWmYF>voKYw z9bNAq7!VwFhc~Lopv2CcmjdnpVj~jgaw{x?3713am9Q`8R#6)J_tebHu!w4+kOA|K z)vH%UDzdzvX!vVbj4V_y0j>tGYWXIMTY4Q*WnkcbWo6~i!uWI)-5~U5;I}G=mF$=i zbZWEm32?KR-g5#E0#sRBn<#gC?D^QDcl6{-Uej4v&_b-%hsT=2( zRxe{8w}dw7+ZiqI;IVhe3?h=}=*qORCcT(loDiI4!b|?veXe5h3xSEF?m?c@r8`{` z{^ZQ{%z99r#_6isuQ6cNG%(V;R+8;MIj`bo^ExyR$oTcS;i2iEA9Pp9`yH!ulE(M5 z;{8aXfk>I$)ZfJ?2gQBc`!Umz zX<6J5i;8lfHox-pM8g^#S;sEdEhT!B`DZ@1%VTLJ6oHDT@*;7aGTc%l{pyKYwTLhJ3rf*rKJFn#`t92zbkuYXu ziLX~HmiU#24}W?7=`qqr>ke`E>(Mo68NI^|KxS&Gs}sFk2TX>n+uMiWpHAxv%( z-L@n%t~j6=@aonsNd$BC?D(y3XnEyfg?R3EJG0*>hG<~hV@nZIfX1D{{Z{9Dlj%qW zhq;FD`KnlF)i0rwm(7h-nqmFohyr(hTwGksd#T2yCrDpG?Jv>q<}nI>5wvuJ!P{!4nU-#95 zT$Mck-o4x7GIMQTY1HVlK4O3U+x}Ud(@UTl{`Vi0tNkw~2H39rf&wW>yULcyK1eLM zUu`+Pd;Ml)vDQVb0zhw6YrDHQ$7VOj9GTw48Ql=`cTcUF+8X|>WOiCV;j`-ITfj<| zyUlPt%<#<2EHgd5$#whVWKe}L(#djwT=I7ez=NX4QWA(}$SV!<2Ec{w$8$lA7rR-D zMJU&`A%?kB(_9lofLtkc&T-T6nC5*7lwSc1*lYHXzVbnrMdjZT;xp+N%T&C=B>BmD zrFV&52;KR-x4MIY(ErQknf zK(zZke_MNjJFF`<%OGkh>&Hk4EB4vAz7>bTHti3Cs}M?rc+PeD+d*vU`=;EzBWuBpR=c$XCBj3XsK zJ>GBd$@=HHJOcC_a=b+Hue9@{#clrR=VDne-E)IzmU;3yCVKl@hc*va=8{rO?_Bb0 z6=vk1{bA-MP5GBEjhoMQ7wsU_>pX!+Pf1IA)dZ8YY_`K+=LeZ|wN&4rdT_#bdqSCc z45vOvj+OWvelC%BasFyf(kILSZ9h`gHCu}_p=X{MY;kaAEKBjazZ;p*&G9t3QQd`U z;SgGJJ^kXF18E=ey)gGCPQYWE*4O!!?-2nz`vIkVM^%k5Ep*-=@M8aN|KAGNE2 zDIIwY8KNCSp~lT9h`LZdB3bxa=rR^DEM>vzCJ%9Yc*HELWv|*-`8}BPc8XCM(>~vW zBTdWk+}v}c5j^CTk&*g+sS~nj$-e8!28M<+V^?XZ;*E^IZxe_*L2!g5<;JwxyKZ!S z`OxDaSvH$cZJdqHYCOxBWNPr>e_7qtD@rN9&%~XTYeYYr@&v>*04p+kgR{O?N*BK&Kh^JE`Mg2RtB`f4$q_^;w#Qjv7+YIl_j05UxalWn9W92P(=?i(n z%B$(;#KL74{{rYfevM9huJCVdF%ibmaodML3}^8z*gy5i&k5@L>Vjq$x4LoZT-ZEX~lXOpwD;DWTIcLqXHLf;By zFr=(GcM~=q=PjG6=F=#)g*~T^QvA&P03=Cp>IHvMMEhCqd_m?MWnJCe93vjoFCX@` zuZo|l(6qeam=Ke0*{~z>Z~!J^*4+!`N>=~+kM{#eicJgFFiokP?uI=f)Ct#E_v#w@ zkGK9%bNUJ+lg&R+hP4LaNB|anmVRqztvaV%$@wPd&1(H{kN&FO}8mzhTwu286j?9SiiFtf%!Y} zF{4|Z7AN7XE*Mq}Qzq$mo^U5AGePPbb{`C7zvJEI>?G`OpX!wweBOsxujc?XA4V&J z-{=8#uoWIEUJ;HrJ8O|~=}3YJs-Qo)Sb~gmeAlSx3{eUq0m+--eKxcA4akKNGDIYu zcqVj~cf^^o3W|YsG7C7skNS;ycX0Hm!7+d(F6f zJoldltDDT6?y@T{h-(y#7Tzh8c)!j0i7uiaM2kF@xsA*Eo1}*t{F_*vNV)mW&&he!xzzFII*w zN-pb3nz(4yJmRS?O!H!5uz?a<^sd|sF%6RK&nc#V+YHut)m|6fd$Y@g3{d( zJdzh=`=`YN92XB+-wI8-Hbl1op)Wc%_HYPRXhJ&%d`idql7eOtno(QS9d5N|bt0tL zl~?+K@D-J{DW>*jR!o>4q?So`?wcqieSl5rlQV|$SoHMMcC|JQZVfhwq?$NL`;Uu| z+ao%8LRTJ-h?z}6FXi7;)ep|2afNeQXKIOFiWKIeN>kngyD0Jo*YI}~>+O72n>hOi z8pF#!>A!!ZZghpb4sJIyS?lWoJ2SYv#*ksSEea}nMWwD=93 z{%}HRRL@C{lP=OzwhlJ=^OmSFY-gr4zeBUORCB;d`I%*v!i6Iby1T`mo*GR-(B_f5 z>kysbS}J$O)iVNtfWzjIkKXj5+0+UsHv}vro1VW>UPK@q2P%_uyPpvd;mEKGjINn7xaFjW(U`x8BOZofzp^-&!~49agt?`+*L`KNYUP+RKL}i4?%1BlyvbTgNN_9U! z*L~do!Tsa6~k7px|Et?A4p*+bGqLzpAIj#OdK}<|SO?LN5 z#NiPBH$8us)uZQc3Vz}U*rid@8IkacbE_Jv0_Gua=np0HqvB|eArnMC#pQ`r%Yqo)IpoRGnUm{WBb z57)-@z`Xu)>8q^d4aU$7Bl0=#)2eOdN8(Q8vuz2{*nF9;m-ft#_!~c>(IuSoLyVo{ zN06jp(Dn30vT;u1Gm8AzQx%Uk{89cFSN7IP$wTJhRbH7ueE~{dw|xEF)=ytw8jjhQ zM|_}+6-+71>^ZCVdsK{V`nP`Jw6QiM9+lLl?&~AZD@TqyTsH>4doDwKf90+0wV^Xx zO9w8UmGaLc%wF^<3nuvzj4;i`8-r|)KE3R5r#&lps9h%L9cb_zTvi_73d9Gcs_nn|UjDn`1IPTdgF3x4*;zOh;KGuYKN9bIl*ZXK9pRlg} zL5!;{VtXxqak^0Vrlewyg=j|~HJ3|*eEpN$8tU5#UIARr9ATfnd{L_$`}7HPxWD?+ z2Q1%>DaNFaHWW9sHhpI#a-6HM25%%s;jeXoJ!iNwr&rom>6oeTqvtCaV&mZHzmXXp zV%T#9$_cjE#O5H=Z@mO5u!El&H+>MTIxLF(Z8*)&L26FA+koI_?y#m=C(H&VH zGo=$5bb-s&d&Qa-O#{@RRFU6|HTsZl1pi$CAx56w`b>0MuS5H;0!;%Gb*l#h$1U+c zkA1_WV>Anyj2;AXj-)v_PBXWeI(NibXq+Vx082g{!gas>%+zn3CS9l3(h? z-96#MeW;B5opkH12fZe855PMl3&pU(7wXSJfdnH!-L$JMGm<|j>saGw#>D&&@JP@^ z-0QI8Hv79obBMoH>Es&m$KR$J)4w0QSHhGxAD6J&$eF~Zpf@E5zfmxn`R2MbZKXNC zw3PSdz%|V>jpz018{rvehvn8?*6t~BC>=lFSE^I?2gX;jT`&l_x6VROWUjt%{j zfyK7Awv@UJI50n2Tw8v)?6vZ~Za*uD?Bc!FeFEXi6aPy8E&cOdx-iy$ti0w9gTDGq z4rjZ$CJ|R?$2GLfemK(YQSOWn_de14_fEJT=fGt;DuKw0)Dg+2P8s7xfp*2*|8u@+ zv~&WQOiKITGlE=U#eEA@4>)3X|9W`M?T}ZT?Td*Cz);R^I+QRR5{^Gi;w)HnTweY) zBz4J|--EOY_$Aa&J8AGr{Y>B3Bjx&Q`$gL7^No|TsTor}6z)eKI=5GEk6HFBJouSZ zhbh4JwaBn_MjMhsQ<8_&<=UgSqz;KC6WwRA^Hk2+JnK!FgY+)78c9qz=E{z3_wI}I zQ}XkG+dCAxuiC}cXn8G!=?(brOKRych;{o=+cm%8=g2ttOGhv%f#Oc;F+-B)4)?Yp zJF@1;U+ewhL%rj{D*tzt}h+j`Jj@%q!S8%k6S!&hHG$GQSHQt!2qowI|sFZNTg zshZC(bACFJ(%}+E$Y0;<0L4~BydXlhHu+8Mv3@e&@PmY}P(GX@sTrT%R#Op7YV2=+ z+P60B^lF0f-uUM7^dWxLGyBY#?hpNfOjwKeSms#EcC7#XMv{3xsPSx;<4-5=+7}%B z>8mGi;;Bht`Y1YAno-V*CwDkr4`Leq5P8$}z1>HY5C6E7mY;TsF7!~JL+Ou1z9(;% zz{IR@TvM$2MY_iM;X3DBM9=y*(eNN%M$No`o2uyn>FgvoNST-3PT}XB zzgjKr9dNASCgEENaSbbn1_(khc zd;+U`sTy31-aPBajQJ_`mqqN`@$B2L{{0yH+oZD-(%FfjHikcaS6{@iDPUyiS20(q z^LO3T#@`7%X{Tf3bD|J;uA?EK9YI^Np)&?~)vMaC*AWMIzqj=R&dy_FUQbFQ;SFcn z7clS$d2HAag^71M^d%*x8m8NzhO{HY&$xOffy54M;v#5{3HA71_#ST&GLsORV%>SV zLlH2k{)ufZ{K4)3XjsFIfdMN^YCnF~SVfxUFRtw93|Gx&Y|UrU@O@(}($3?4nC@Ep zF)zNCYkel;%f=&YD1SG0T>X1Y68a&F9ou*$wQaf^#o$`lX8-&1b4tQzih0Z%mz!e} z(>g^EAl^&qbglea$Uv5`{SNHEi3#f*Axc)+jYyN%L=BireT}&B9#pDeKV!IsI=L_-(>%exS_n zzW;_`-*Z!8aHI)@!H{o=3;!eruIs?0b~3cdU$86sT!b9V!C!y9eglFG0Ky_-%*7iV=31OSREMP7NZh6Nm z{{t#VJfr4BL48DeqUJ=*A*JAAWd-I88}cyTjmhD{we6_-ttd?)!?T8l-dC<%0qOCD z{f#4s4P2^Lt*=}mJ>PURk}sx>fDde&aox~DchFtda;uSnD#AfN>s>o!DF4mR@zYWD zJT~3I&{+K}6VJ73QNP(v#ux2@ihh4pf1^mEcIJ$cO|q%8CROwG_0FL-Pq#80ahoq#So~Pt^Slz)aeqIR z{z;c3eqr_%B7NeN+)DAZD(ptTIxj2cnK-@rJmb1e7=~Mmthw7ea+2lXNmvtiTHn;i zvs#NZdB*QRD%xRyjz}Ob?bZ5ENVRDrLW=CJ@IklajcYRHr*m&3I{xqT@t6DF4o*nU zy5|859@F8#lC@V|TT|9c&bhkMqHF1YXf zemv^*J$K;h+C zpZk`Nbt`zeNc{<^Ti=N2-h{~*<%&*!xcQ@?p*6+P?*#)_eR#9|hKuVMO5MKynNqwq z*!^{H?U7oH(R)g5_#QEve=l2y(ev!W%Bk+rAC-Yd2S&%9NFjhLHtzeWIE8(A+d5a* zS#;$EmFIqsyc%zxir=!Yy!da3I=SWzHDBLO@p$qtcqO0Hu*gUUP9PNBU*^-8e_bmd zHk@J}oH%*)Rlv#DjH@f1|9op#&XZ(IF11@YQxbXotTdVr>sqRO=cV_%hI#lJeVMGg z`snm+a=+cXGpP2lizyHV-ReHk#*V41l1vPpWf#RJ2Wy{P{B3{p#Z=y&!JdGB7pi0bQT?tLXNUF_q_n&q z&=HR#HI-tDM!)>+1q?3E#(uu(FdzpQUpcUAmpeO4dHPD9+E0 z)?Yo&1m1w(ijS|x+fyewh{TV>z~(~n$37MVhV+}iN|R}R?_$SwUk+C2_~83<$6~*Nt!sKxETZ z*KdxQvy-wlbK_xl3eKb>-^cTFwJYZ5upYmEdRCat?fafZezi}-qy$d-Xp7F0ek-wP zzUZb>{N@ntmD{R17H7UakMi+I)E|ubw%K{AQE1YmXh7M$rnWsyPUP<|zH~~Vi^1vp znzJ(1uh7Uj*#|;JGU4oPWp&@86qT3#w@=0Le|P8T84FlinfO>e?-%2oSRJQoq!#jL z+W3_vrTIAx!IIeim4(Ns_Z?r})=z)UefC|ccyf&zqgS*a??kcY_xpZIH$2v=BZCeS zd9ixPW|d?tu^QZUkzU~6 zb?yB-G4x}X*+-KvnmEn#9QJ9tw^IC)dGxo(&(a;g?(c)6!^yrH%sPEPmdhxhrVQ+6 zm8W;WT+rd79lyW!E%}3#qo;mGaL0>lwSMtbG0W>gJ2ddu)XaOOSeKqdUeyJ^VkWI# zHD6SYC^GTR?mbIc|Mjhx1c!RdkrD6g`AbUy^y6tEOo~$8I_&Z>=dPP4YQkw4$~r3Fc%>oq3}3cKtR6`p*)px#drIADN>4QYsE#tM1ErTbpXc6wJ|ectrF z_$0pncZN)=zpu*4hd!NT!qQih&V1$`dS~hGY1w|FXjK3EGai`YmYp5hNpNZY!y0fq z{RVk0SC$q#SQ{)I&PX0BUlNlt*1oj*aSv9d1X@{>M8JI<`@Y_VfIYMmXf>l)r%uIblnQz}~PI!h~Ey{r$(?lX^9 zR{WK5rhM3);*C`Q{tt|*Bg5c^@s<{~T8o_Y^u;gwo>G;_fhd2Nu;9K@`_qDM&$)t(hz{jrMaD&F+K+wt zqKLFW?C?G2b_JIkq$NtXWxj@S>OXJx^7p4fNWvgKI}Y2sGKUqBJ1ZdS0-g@qe(!ZUiI!3PF%p2HfkianS)-b>FIWcs z_AHrwbkF6T^XL^x|Hl?*3i`kfXX0fqTo3g4pc{A^Lcz+85l=8Kpc{jr4-9yZW(W47NEUZnqpw^`Y8FIN znWckn^>FYFQO*Ui9YfXa#9+T}y5;N*CB3_5cmF?FpT)BXM|h_`eTuJwJ|^(9Pt7Ql zLg;=M4KCpu7aA_gxYJeYksMnG3Vmwpc z`mKIy(_NjP4#>vCyn5j63iesn`fkE@*gB$JU_BZ^%z4aD}L3-X+ahh!MJZ1dD<`PYVqwz zKosldR{kI693>*TEbR&7p#R@|>Z8Fw&=W&yh20nu zc-A3aQ--K^g2>R_Y(yHXYMV(LKdvU z=L?DP{RIKVGi%)9AF=P_3L6?4=Hk)}d(jd)59*_-DMwS!%s-ct%hKI?4lbUdrBh+l zPF^D}t%G$xUce&_6|{TDbolT{5a#}eaKVt9|F$^UuIJ*eNBvLiU{v@wo+>n8kb=6B zR;xLkzSPS-Glw!&`Td7qYyOJF9@*?qqXHQG}0f?|SeQS-2?8MVRYwzyt z+)A~_ITa>E9vI{Mri-t{xQL&U-~Q&+$JtLfBu;;_- zaH{SG?_>xjQgE}YGPk&J0X(1_^0*M;Yeh*8kLfDFA&1Akt@wFjM=OGlj`kWwTl+pN!DrDT(@tgQ52>@Ng#fyzgqqeMRllrJb0 zusI+Ff+~v}@J%PIQ~D?j-E-zsP*8yN9;3oj_HMoXdR~u1UJt}i(;n^(?-Kd^YD84|p7WVzq*bjr%gu#}hm#oqEyzQ%|xhnYf3 zL$B^4^B+~lOaxgK6e0#E{b=ZG5)C|Puo&&ihjAO?T*!sQRTu|YmdW+{O6mIWotlMhkv4MCXey- z4Rd1%5I9V(t*wo@qE(f~7oWd+Vp1>^=Me_OYAaang{h@UEQFK6`jM9(x&9Zai>d#f zAf+->+aM^5i%Uzf!N2HnAn@Vu;-O%d#HkCW$U5Hg>1pl`=z9UoBZt_`7E(IU)kraq zD+a@j*RTEI6M>T)FbltsY_Qfsl!i)UZA4; zeBAPfPS3*Q*e3DKuyxtl*}1yXM8|}Scj4h8CTTv{VhU&9k4JR$=08bL2vmUb;qNa` zMM71tS2~EAG-|u~`ryL87GLbc9fN)<)vW0N^(2Cs$YvX~SI#l1jf3EZNqhi|HLhU- z1>@k@d*PBIF5=h^Lvu`Jh|)*tC~Wp)V)y{}VR97Yp+W<#Qj3?5m-mjW0nskj6AB6e z8}mK*TQ_HfEUVzp86F<~ecPWae%#&as&%rxNLlYNeQGC&t%dh6)%&7zlo4aIlq}M^ zf=QS{ju)))uiC6^x+cTslEkOE^2o+leB459H+P#I>Qcc za=aLDsGSp_k8-93MI`0*G!NzrC4dOP8;Caw1p1fM6&xd{%%LTKb50 zmpZpNeql&{B)*V%9|Hkcd9Y1HwFjr+Q{26$Poa6oR%TP?y}fSNIU#<4a}#c%zO{A0 z2n$3p?qf`+M1!D|=B4y5^kK3A%jROLiE106LZT0335fb24XBIxm-gi&b!OvMmwHn> zaJ9Ik#O4MphV(>;wLhB*zkL2&TtOlF{p}FdN%7Ve?8o~rz*CVvO8qUmQuF)pSsfhs zv$P3pIy4{d7ywvdfQkG%{D1YVLWCF8M4#3I%9apdBGyZb`>Ah6#5a$w(Sv>V>O_%< zYw~(HxMXM|SQPya`^o4FUw)`6;;UqTR@;D>=o80&64u~5cUkU|>w(!C1IL;xY^AZZ zw^iDVDx`}b>c`24VUT+3n_zLSX7m;4VCOF~DFryhr$Td+ub1Wt_4B_V_hFcX!obq3 z_#?m>$tfu+xl{o>P@WCkk})04p^#C|!yN9JJYRVk{H3&cF=)J20qe!KM^ z848xQTOf+=twjcxrX}8hy$_>1Gs2V6*f>QjUaJR5xTfe?Rp?=BHYm{MtXm$s>Fy^> z&&vF7-=Jlkf11}BUD&IG$r7Y=-%v11-Y20dU5gh$q3LN`Orz6BAzoPAKgb)&9a-^9 z*qQdq01g~jLOfpD5~`v4^#c=J_`vws{rz;c@BkW?nl|Y-x3S@m5=iO5=7%^gY`OPn zh%)C#6S2dcbKf;(c+LhDrfL^_tD0lmyXX*oN0pQ1Ac*HUPLWW$R-t+Oc%VH1J8-e_ zRD{Uf?sJRZzQJS&Mv^~IFaId$tcU$8qw$Xt<=nWAnfIA82Crib1@ot+{_RNlE_bF$ zKoIxu@1G`O!4r)ygmP&R*r{^|XM+@7|KbI3m6K~*>+6`_n>ju7qT)Nb`TmO`8YGsx ze8ix-DeCc)~ZpKB$M(cf~jX!26n1p@*_`mIr)8gOaN z$7zeBt{rM!!Hhsy5l9G{`L0zgyr@xCh2QQvAyZDuCH-YljN@vh`SK@)EAM`IVAF-! zNXJK!yief&y?KKTeFtv4VH6hGNN#S|9;J^$Omx??HI}_~4_kz4OKWS{q0OH^b7Vc9 z)YqSkS4Y6X%4WRfEd9E!&O#&w10i%o9pQxbmelCq6)oQKso&T%AuH1^5WQF((q+WW zxmXJp(?Nn09A_sEP3#QNiFno^8zb0IGTpQlaWlv{t?>R`LwPn@WiVT!iIUMBIEzVM z`Y70R(y(~2w1*!Ifbj?tHTYFa51OAP5Z%<~qtXrWy?yT_ zlmgY&)i~0S1s?nOebC`}x@P`^9{vO>P@RDERd!@zWIQDgPDIZv9OaBGx1VA=^6&tj z@O~M(j*tWMisgQ8bdW`QRha78vzTY}N3H`MB;1~Q z2>AG@e6!*Qd#xw!iVsDdu5g+y2vM&fy6007MHn#L3Phbx1$(Th z2nnyJJR6$R^^HODWC`uOmGnypMG#&gmP0s-!h;IAGdgBrdw9xCg|ig{(v1oQ`L&9H z^SD^&&!{kslv+yb&t=!=f)K3Ih`H@Dcy%^v+Ks)UD?dLUi2t1&VI}!+_o*oXjvw5y{zTFCt7wy55kWBcDmWloh;ek%M(o4vxl-tu3Z zUeQK0;S-=pt(_%1;PeX9bSXAO9QrGSX@P=1f_d`-y-f)Ye(ah!+RrCt6T28G1-=(( zrWlicR%o>)YqecuD2TJv#%2;$b*N69=~pl4I}^jgIem=fAPT=pNlE^SsCr=i!d-iE z&08@iwsneS=gw?fosybE(-ne^9%ZKf8$D;L z#DP7t;>?@-?(^WCoz+K4f`Pez>(A!HfN_8DMDw*QLi46a;sp06O$7weuc_y99RDTM zQYo5W^Lq8T!h^NYkW7dv#X70~Jin0itp9tNPbwov6~1N1?>sRTrXjs`s)8XdnJlys zIpV}+L_80wGRnT{llBBvH07UJ4x7}W>IX6@T>joRgg_wAJXL+Ol1cTTibNuAY@gn( zgC-B6>NSNW_wvU+Xp_iKxOqg0c74d#XR_WR_d zSmhKHj%LM8@1886z9pOW9-x+deN2e~adgBWS&X?+UDpc35b+PPui!-?wrLY-J`|>M zOY+8z8%LhJG%K$EyHvk|OJHHKRk81AE)Qo#+XTaa0ew;dw1GBe32jko6C(NA1uE_z zaJpoHC5JE&IIr-xkBL{`SJ5fylRg{~&-?N9^Pr=oPL5)2WhKd#3oyAF8d3`38NTG= zqPLc)>It+u!VIXI2lXmE6vx|5h1C{Mdb&vcJtKTTE_pZgY9`_wY-{%AID*da^}L!5 zrmA_hdm&KqiSO{szFgy;2?v!G+vEm-tfm((oaIdnKgde+IrazRX&LkbfR-n^-FP@T+ zq(GgIM5r8vAH{z$7!4QopmP)Gu<$Q;Dam_aD0uzGjXBpUyzMv|_Pc-qMxTDLjVYPdeT#mg_r4>S9B`q#JvTP82MT(Iv+!WRr^koN7B2Ar*vS->NE?8_}(@) zpt)n^&`^lW%d^C`=Dd)ObO3c&wmrmJDJ>H(yVq`B(#bzq*GSL4;eEriM{o?VQsTR3 zS0T?XdTv}qt?c6r$fo$3Q}iK>3hrNxz1tvw{#E z85p_fg7%UR+3Jy2?rOO6do}$@_lw%v;g^q(#qLy zr*(fo(HEptm@#i}`_NbzJs$YFKQ{Z;e$oRKC+q8`{id&^EH~H6T)o|@EI_^3708;R+j}GLN5ZU+#mGhw4$=-Z)WQ7RqGS?xIPWa>kzDcg^h) zin;GU>nxH&yVgTN@#XbdZW{1MYn>+=5fWfsUpOwA-qX{A@8~Y8aO_yFGCT39b6Q$) zp94TBK-9FhwnnIX?m3&2VsraS&aw2=ROf9;-8aZ((3}Zw;OL9}t~b1mx(M!n=EJ+f z*T^C{zr4aG;qC41=T~DWcuEE}kvCy(z$8D_77qNR_JE`#=Zhz6$0woeA1qR@l?cqm zr8h4_g^N^_Hw0J?VZ|ag#jgqHt@m=@ng#{r`mj|)Pe#ph+Vb(G&Le+{H2YVS{c2=P z+pc5RS#Ym56hy_s00~;^7y?Q$MMZ*#9ccPQbsWtqm)MO;h+NBwSsgng4fJhRutKd; zPyIyn>YOK0#oVy5qiV?3zQ;51gx50r?kK-9Qx*iakT`PFxcJC(+X)s9{wY?qmbz>< z6*bK6l9U+~2jnP2T{B;ygT()NDqKG>=OS1D}z2YRL|IJn^5nJ!sRn zwUO*LtT%7;vs_73_TYL>a-Cz7{mfrlWxbH;c zUS$^q2jTuz)zy*l9?s5~cttlaI+|j{CEUBa(b{5} zEme{0l|sCOyxaBKwFBV=xD%ytz6V}<8nX0YMH7Tci7TjlN zXWiKc6ERS+gu8|WRAQv&OL_-pFRQ1$6$2Yh}Rn<$W^>3BzQOvRk|Io)MG>yh<` zHPm0ks^gRv9%Ng}Pxn)z_;x=tID?eK;4w2f$8RoPYmFUO zB7XkUt+5$3%K~?KigngAnUjHXL4&x(J4pc!EJhx>t`8r#_b|&CkfzOh-m1J6oM$LF z>NA)1`UcX;V-`GT`FCwk>*l#G3PaVZ!HpQ_$t-CXu8c0OCIn1YqbG0fR2Jl;rAV&d*;~<%7Z0E>#gbyaVV-cS{qpB9mG&W==VV0bo~p0R)0; z<$Ja6pjyaLv5R98H$wGU4gYsjN!Q`%5kAE~nrgpBoL*hNe7S7Q?LHK}i&)b?N4+dL zsHEXW3#XfcK9q;t-3gPjhr6kK`K2SJjH`&z&P6Cul5%VRe|(?Tse!8=*RNA(o{_X0 z@Skyfv$){9$2)V&sDFDqqmG-Q(cVE+Bal`h+ewQ8z0xGchUYkgaffF|oAy&SMSY z;F?R(jrZN|jc5v2(wwnOB4tsl%m5Xh6W%(B{&msqqFvfW4TE&Qc!wH41)` zbY$=swZ+}+;RD&X{QQsv_3O614^%}y!f0gi!L?iAoeUXLkz`q~wmoLM(yLjDJMr4S1HO#}(6IlRwjy^FB??YwYL>CGD z)O_h+i=9b^K0l2AzvIg>H#5^uYXr8OAkgRT6thmv;TDa!PFj1wco(r#iupjja9Nuz zg3R*E0y4^y|5{r19b|Vm%yBVH4irpE&&+g0q0sewQ9`z=#-;t&jx(Wf@Y;WS9i32^ zb~ZIN?d-_Q9A$|~J!x*F`uQH2-n9-pBA5YReL*I=ig8smbQJP}ZP1Gq5)z6~eV|_` zre$XQEH7Ke&HnoJbH}1Fv<;m}Q5x>jXwEevO%^$+V1&IduPG(m?yuEOo+=|e(6UXtm2R1WKHh&eKI za^}bp4M@X`1f88A^ljMWO@-+(H;=+C)~|Ms;<>wuK|&v%@z)0JVJ3~`a=0_zE;6pf zr4@+tJAul=4bhIje`d~+*lG*c-p18`)pnzFdqu7cP#B&z<2s%;?r8LQW^UX6CQk1o z#7hDyyvC78*#%EmnM2Efj+E*CW5;Y%8KOA`g&z5zsbra8`O>d~;s~Lv!(m+cWQ0lX z{qBcU0^H&{f;=kQc}QRi4F&th;+1E5_E&QzGOwKtr)0;ATPqyp%SCw+O7j$k(Zwfi zrVJwHm?>HPl}Nup^H6YaTndlyQ0tkd#Y@!3)D-uYA9|zI4L$mk$9rde{ti3{yZiW? zF-L2>CatevALj@Z|B6taqn?McGC>Jq>VKCzpCK!2az{HrE>>KaJH{B8^Po6w+qWP)H)sq3g+<}W@XJ=<*Y#46-cq%i&w4f<9 z;yuQ8P^atVI}pyvdpWBxW=v1NN4?o)pa9Fpea#J7FxDa=IY{4C>7t}jDqvA3p<>cfP6%SG_G&T|$ zy=nfQHze6(@wWbTZS6&VI)Ybj@6o$>w~u_4K1^=2kiu}9GxVN7|GuKX=)$2AmzI&? zcHnL9EFyaB>pkRK_i(uv&p8McWp_LOhPmkz_MNk8hkr1Eyz0-2Vjl!N(a#8D8AcxI z(hq^y%hgpH3cW?bW+&`}M;=s_W2O00UHep;dQP-VK&|-!>#oDkDA^V7Cb^)Rk4*t7 zEtNgHqQB{;u*(6IX9TE72<=O*>l{)_yZe@#@l6nfpkt59edWW#Af+<`G8ya1I8#69 zI{VWYL6s(!jg1OwjOK@$&l0^g+ZqsBV*IGHvlC6dUNam~^TpT^6PH)_G%#~ zv&Be9>-|}CwmUD2ZGQE3BRYHdnrgLL9%pugQ{|JCN3@G%UTtKDyUP}z3)6US$im1d1Lz34 z-GrGI29V~V-Ep?--DiOw-lFr=ZBSccYxShKa;q z8u1Jo3ntE0sutvo`1%6g0Mv7xCy2`Yu_CPfGz$7Ald>~1nAzB%oxqJpNaRoHcR?_T zD?7V!5xszvjxry?;CQ25`MfGx(s6-aoG;OCKs!yDQC0dc8o{USEPX!v`yY%Xp@3}` zC0k}@CJPf2oFSepm%)f-P25<4X>;B~Jsh0_=ve?CfgIq(JpDwE@uLb@cz^t+Xx_kr$W&|t%CrR z$PC;cZV~5WMBU=txpM?6na#03?L3YX_3#KA>Vw>XV9I90NH5;xBE>urmMm{8C)gn( zBEsc}h#1E3gxDl*o;7fu`a+LwQwH~5jeQF+k8{6KXoy3Pg_&7J-=sYxHunIHT8edf zjhpg<27{w<^Q7Vmwu^i`UkLyV1YBEKEQ3{=?RftCZ>cWW!X}RsTN9M0Y&bF3p7H^!R zt!+pxH81;O%_ZZ&;SP)0(!*9BknbXp$58?hN2(u@08%)35(cI8^3fQ*w%*ud5Pvm6 z*e8-XSu-CxzpK?(G#<2a4b!snY1(z!`rC13HnY1z{q{VljOom;@ex>I3KY%r&?oa7jG+czolOkj2yjOHA(B;2e}OHfvtEITprIa7@EC5 zBcy995p*G5z3JqO{s6nv%Uga!3l<`X@mZ$ijvwcKci~q?$r*XBSVI3OO{?XM(&gUg zf-wHT2cY)xJE0~}h2sLEuCNY$x=p;1k=H)4a;y36LvQn9jpubAA0Id~K)`@~t;&}b zcM4sSHk43l=9T4o)qI93njAZF2vRaNwfmU`tIaz*ueHkY%3`<;`jdsVsaCA5^S5Y#O5%@shlQrpM>mC4X??EVCYjIKGK^1 zE>`-E=o{M_KYN=fSMrqmC5c_*hMAY`@-zD@x3~@)P5uho``a^w?Nw!^I!aoScpq@B zhM`Bi)i&DYlrxg9ZllBe=0)gva3{vla~70-Tl!?+i6FL74vRC%4{HM3lQ}aKJ{~{M zcwEGZlcdEY@DQc6L2$uTnO^u~En9xNYTr%4l`;Lohrfo`Lp6`4)a;W8lCJErcZf6L#PZTTXn%^h!UXHA;>XkA#;CW~9EzjB(4+x}i6qeyh+o8l74D z@}(!d(9sNm5JG=sm0IWAxrW;%EgYeDNZHyw9k0mBd8kuu*1#kFoh?K@P%!YHc`fPU zepi=2B)GqW9Ia<;f6zpq*(p(XRQ;K|^B#pkG%Sd?EA@XIrLM0QeV}FhCH=@{Xh=R$5J(NBZui6klZEx6kBBDC$vPXjn@$-~R}2Q-XY7GUK%3mo-fzL0z`sHWlAfwJ=l) zfG`R_2w`~2dG=h*^GW1fg~E^&z;Y6?OD$UiW6nF<)DrHjpEQMgLy}B|lhwI7X1VU} zZhgPsf@OC`bnNrxz**+-mK2J3ggR?{RRrtUy zZuXb(7nhWfI8r|{G&F?Ee`ZR%q0ZylB^r4un=9D+#d$ zj2XS;3K6~r{#ZW0e8S0M_fPZcgZI=j_brD{-!7}Y^yTKlSxe0o@l)F(q>nm0X9VLC zHtlA0oks~OZFpZ+`XKMdEr;J7__@^^&r#C^W{qxv9bwnBh6?A`z8jj8Cjnhf zL=)1^N<1wO(_nZ6Gj{{_8|}twA5QN7fF!Mzi{XRcbV0tpK)<~F=cmujiq)by49$;I z?fh^&;1D}hPO$n(ENo=DcStm+J8E2guf`1*5oU{V)WM$ZiL>Hp;T`J9w==BlfFuu_ zLR9l4RIsqrJjloiAyXkj5;g$ZP!wn~=UP`hP$0^wqsj#N1zNw$3aG{omB%j+--kY* zw1F~I+0<5M50Ww)W$4u*oT)OW-@d{XuOx{=nPJ`TkGw=4(gG2KhTONWWvV#jN%JIB zI9SM2zeU*rkWoNQ(zL2w&XwHEH@n34xp-&>nj>&H^LkP37l#Ovt|r_sFTYySUJ17(cVmDo;^gx8Gr~#I%c}mi}K;O4~-HAGNgG)&1@`++ZUobG>^^TZr*=TAE zYgD7fufgD1nD5y%_Gfe~g7#gP5yx`mm6PZr$jDSZd$tPS#Fmmv*49DK&)+*|n1F#Z zNUD+bWpriBd5L6nL0xq$>iAsF3&XQsS33Mf4$&zeZP7-sH$EyDS2EZmQL{zMe4m9n zur~9eMJnAD)QbeEW-A zpA_wNR98_<8u$wZoSa+@s$~@wswDaU0=&887Lih~F-~T}@z=Ln@Iav7HieX3nE_cK> zpB^t4h-A%3e42V^yN>dhePc-3U!U?CPt}~`njdCiRM8vS7Bl^xbue<1W-UBziXwxgysCD76 zv$ERtEu=BX{CX2@a$aC_Fl>g^KDOdUK@vMTIk~vFh;LP>m#^wPc)2m^_hVulIxu2` z-U>?*=@~vYiyyxU{GfnWDK=ih*f_Q-FvdnpNEvJnxli?z`d&HC1lSnvEWVzul`22! zNy#sVy^+(iRzR!V`?=^*>m4_~&iA$3lIQ*&p`>;~V$o zGh#_nq-FZY)&Mnzx(oC5JKNu56@Sfxagfnv4>l!~heXGj8SL-aipzlc#X%xP7op_) z;H1Q?M7+ta0KP^-cLl;?a1j76-9YiQ{PPZhQvlhAz_Yk_wvfrNLdR!lYO*HiFa^(F zrSA+ggQ)0Z>%)M{#sh|0$QtzypE{)}Ot~lY{L(e@%xt>SvOba<5xop_LaKSrQ z_s!6$5sm=3S6u80XBSMYGx>+M>HpPW&Yx;+X{ngr6Z8g~6-iS)x*i+*YLf-ai7aN( z2aht3wxkT)b=*_jL9*2riCxg?bPg@;l*L@N+ zo;FV0eY#jv&W0-A>Z+J~FTZ1CV}j1RqbJ!TR0%z&6DRV;<*+rwqZCUK`~1(bz(CZ+ z?&dW-ImT6IWiDmr`=Kh5_p{Y5NoI1({gS*P{l-N}?`$8_@F+6=m`7Xt>I*2Vq#X?# zmjMv&kEz80cYiU(hjgCX?-$>(%eM|53bg_NqSdBMzfjd%iU*^3{Eswkc_VMzypBH< zO+vBL$dWwmy7tI-1y!q6$vfAGM2~7ca(d7HlD+xtod+?GY-o)Rhmp-Y3vzsX`t<4e zY#lZsqo?O+xG7!tYG!eXheJSdHbvwRSt$D2Y>NJsqfYFoOIlm+w*QH~C&{w2aOLx} zKX(auLoBVgT#i4+0RUtL%fCsPeB&P6arMZpPmt@QCfy!zE}Opwg2sn;R26ejvNKfj z;h_4jM@o=oxJzaPKrVDK#>a&i>N`s)Ld-=B^5+Rw%p(G0%4Mbx6W$X1%Feg*#I)@^ zGGP2z4<6iPd$ka)-|TlR`|W2)OgF8)e&q>$9J{+eC;Q%M#%lNW*6JnonFph(Jck%e z$f$&mrRH3G&ZM!gqGA4SP zj#RU2@!4I-HJA{(Eq5sTz;of=(Ea=NwW&UcT!lWuN$uwQ*{7;Lnr){PB0gxO>egCx z&$tpB_0kwpx1^Y0z|6@`CH4rlM7So`)r4|2v_R0PBIQmcHMakD0T92hYnp|S`uQk-dN|MS;Q<~+= zmoI-u<`gjpxJm%5kisGlt`desM%&bzC!|t1DST=%8zU;Jk~$?W+0Gqd`w#0hxkez( zXy>qqH9?rgPltYsK1Zp=*juUKd&0CF1((n{sL0C93~?qU=-_MW>exsKxcm22&1Dmh zD66A?s=snp#V`xz1y~jRQ~RlX(zxZJN5|`p^LHctFbi@` zG6UNbjP3))Ya$-@HuLVyRN-?A@)^1Vh9Q5XzRxC~%TU*F>5)T*(kO%1t z3;pHUyO4<`+k8Mkt={A}I%}wQ1y?N2KB>+sy`jEqbw0m6(`BYymCFU-68J^uaFI1f zlerbf6>3Y1i=&kZud6jP&0WpciL%n=HrSGejKmd|R(LsM0w4GS-Qzm`W;f4X4TjUH zznl0Jd%)Nsi2WQK+KQv|HG~2=IzIAHuYCJ<(r0}d!8d`{^u(zlz`WSFej{I$`a^R| z{)S-B!d8W)fL3MCozr^$)YPeh%2Fp!mYNIXrwZxnS{RteXDgiJHhKCBx-g`^U>sw4 zuuUWr^Lk%#cdsxPx#8$&{@Ob}PUaO=xPC}P5>VobkVx(9_*+_zVbsMuTj(kI(jfK0 zZ~@Av#};|t_f8xBIU^-NIDO$WpemcC=)F2VGQ#qkO}?tw_<-4gD;?{n)d##Z5~Z^Z zD^{RJz=4dRNhBzyTH%5$eWxqEOh0&0z}+Awr$IjjUyUQ(A4U>{ z)a+t49a$(rP6oloGP~n1v@eDbC}4_ZettezCEV73(zs;vQ?Z(G$Iq3?jL~PVFAeXC z#GQ;gkSi>E^K|qDb(zY2X-dEA9QjxrWxotrd#Klxwq$6&S0S05pK*4LI`(dMF_+o( z(%BCzXs@YVUB<^2jSL{QC8IHVsQJRI7SQX-$p_}$J0ax{%|#%oasG@ksw_1U{^u!v zcW!gv?CL~VnTC66$jf@e^p4AG3|d0sN3u!hw%neT&KdH#F+JS8=yeQ!Gc9?P{A@F; zo+~QoI$By*5^lFWZ9j*JMUn-ued1xQZ4)XvN-^AXnWjB|Pv15UA%8;>uP=1nmmj7oFwU>&o##@GGf^SK1O+-siP*4Kty;qO(%968sf)SPmRdZ|aCx)r%+> z*V&?b`TfIRe#vji9G^tOEP7Pso>(UwsJSTByI;QSy81Q(dLN&(0je-??^0Q6(Yej5uQTRg@X;pS$opW^dqx&g&kt%9&u!JL-F0VYri@-cs5qFN z)IB#`hlfmv_I=2tv=e0F)VZPML^_YT0)#Y2;z^DfKELZQ2R%t@dOB)`kkclQ^-{=k zkw~U#O;WbDYaj5j{8~1e)I1QBei%JLh#ycQ2>y57*H@M;mLckN@4bksf&K>+PM&E? z^~ySGuYy*Tt&60qNe_mE{6wIE*o8qRNU+=HbUV2eB~X(VZTx4C{-5@~`=9Fn{a*;# za+K_h%&bH>WJX3tR#q}1NlqM_viGr5$w?t0d!2KPP_jq%d}T*QMvjc?dwIP--#_5< z>*x0NgWD~)%JK9#kL$Yb*L{RS5eG)|bG9}3506*j03sF8>#hY?jt9=g2tLAFgNxyr zxHpYNi;QvcMVxbK+P?GI$)_0Rjd%p+dL+pyP<*lXURuMM{PUVEOfT|{-DuXaX@XU$B@CZre@J+<+Cj7Xv4{MA#BBuPuo+WbEw)Dp5ql$$@JC=+`Y$WSl0)1w+_* z;MQC#(20OmI?R(0zLe89$KBY=dB7v!VgyPmv9E|1fwZQx>}BHxsrO;hLHx_4F7#m$YD=_@*Zt^GQBYfe+n zE`}zzrhry5-av@mgb#F#U=EoSFZCkY2fFCvwWX*`vbHtc&;)LA2U_AoI+xmW7Bu=? zVU1SdRvDY{AWZ1L+%9NuMi2m-Mcq11N@?paOSNlnA|?_8Ak}2Rt==`BZTG|VUuKsX z#BqQB9D+a=c*kH=31DhXP0d&bOYQundrtS8rXXuWC*wHeGqpp57ZM$bFhzn+S3Qaz z-shX51$%2pmOk!JLpfSE3PF5ALqh`#LLepjVylx0i|aUFM@Mq!UEo{6ybrgWbgk&y zN)Ny%p6zU3C{P->1oc`Hi9FhS{CCf#3xGePyAhTf8wBz4>Mpi4ojlfTXtCj<2Df$~ z;=(V-xIjiqsySG#(#XD5U~$E7>+F|EpyETb0$oPs^_D1A>NcRb!*PuFfL|81$cY$UxGT z(#+-VprdLAnDLVw^GKrD#?5E5B@v(#YIo0*xKV7A5x8Z*n{rQ^Vow7zeE)qUt&ax!e`dOV>X80s55qv5n2wAFoxbg&bs7#9{D2v(IFuQv&>H%X#0|&rJ^iE>j7jFP5w4Z0UPc*Lb9I92Zlpq(R zN_0QXy1&eDKT_gID{&@C&D6D-yLK3l!SFT$-|^9maKdm<&?rl96GX#lkQ+$dMPXsq zZzf!lkxA=tL{4N`1&r~npT`|Co{@4~2nMBRtIIwsc3Ka`f7jS9s8Hg1z@2|;CLg5r z**1CW;_pY_N^&slgS6xwovLM!(^49pDT_OOb98lyJn^+P9X@TjJS6In8oDP4J_CRP{(T z9?+}SR!y%poxBzbj7V=3oL3{w`>w984i02_SsSJbIuh@w4xojACXx2>N7&8*$wJ2t zR%_?ZojcEIMr&e8wd>C*ZsNsGq-!X+UkSZ6oNYJ-uwRCTH|^p)y*mv{PsFORh^U(y zP|Lc7Y9t=)ikC`RRSgV`J%vv13P&SMT<@gvsXy`eqKF;Ud0DCmssWph@AAP%zA|hL zKxu#v0G&W%Q*8;eJfols1z}&(9e;l@!c%By70s$GA1D8ItHJQ?4q)nK{k^@trwhaJ zZI$xuw90_0&73^ETW;~`S;7kBkzd>9mHhy37wFo7Aq-?^3o&m{KGjaH9|u1Hi_G)Y zA&1x+s4Gg&zYKc0CM9*pT!e*%h2RIhzupBt?{CmlxIF9-M|n| z=bDKrG23kL?VLVPr2b~=o2VuIIX@BA+p{oV3L-}@FPV%kSU0XLZNKtJ5PjfjZ2u_r zzIKa1-`r~eG?Sdb<+{#Iw`APFA5$gWYb56PXJ7z0S}Wl&X^F;xcgS3@6TON?B_2N> z=Vp?YJV0`ae;NH4EfLa+eImYcmwL5ybk$xWz5RyS{nEqIV^Qm!+RZ|SJsRO{?VaUt zL$Wx2ts=;jC{XmJs)ihFc-?Tpffpcf!(a~qYx!<-D47b-2>>AlbdeXrBm!q?>X(2x z2GsCl%#&0SLcn2Bxe$8OHL1lMBuIdY&du5955m6K5ab2>rGkbFW+4e*^#%JWzZeGr z&6g@djp6Fi=FCj?!BYh3elrzvu<4%qB86u@yxua^WCy98iuw3hLVBDsU7^?%z!Fv=G z5Y#XQ!iG!qni0L#?uX?QK+oOi2e~H$xx37ts`)v4pY%S}jMs-iP$Q)YH6hih#}5t{ ze{7G;5fd(P_JCRfKh*vX+=xKv0W(EJQOJ`U5gOJBtqzq>+FzHJ{s4J3aIRn=hSRj2 zWU;veOA5HhwQ`K8ha@?s+ES=#a2h|q+QUu?W{CiiIT$l5hTKG-M zGaZy3G01ZK-tx81&(XEiK}V?YNGd6iE&O@yNVxs;dT9qh$}_a7Nb15Z{kS~Sj`MZ8J={DILI$x|LoSlKLg<`Ok}Vi z1LgyYaaylN+>_<$tst}nukUXX1cG`$mjbb|b(E2kAx+=+S&VM zW<|}t9h2}MUlbFA!q}pI?0$m(f~=^R6j46bc-*)Fc5I|f62Q?FLV!^-B_(BRST1R( z+u6=7v|sS2Y|UWO0IHD_g%Qz8XTl#B;)s~Br0)^|~6!FgZx!zsKdDpn2 zp!HMdP3C+tz5|*cK=>MOUtsZ;I(RxyQM;d$s662!1FgQ0+3z(3jdZ=_e@N>TQ4b0K zQr&-H12&lAV5|**bsj9XVU(E7g(rDlC#2yrm_|Vt2lt!-aH%FHER|nf1%gR)7-jWe z2+TOvu|wkzYL{1iu+DM#@L^azgX}#l6$b%eiN2bZm7MaKL-vh3Fx?r?R-n~7d_agP zJv<|r=g3Z)8q30H9iqd-?hPGOx(>)@+Ay49F)5zFK<#u8Rr?Jt#>aeQWGtnUwGaZt zG+LpVgYm2lRaG*Qk`PqSl2+lsusj6`T$a|>xk9SI=gZ7gM9qc2$Co@SxpIQj4eAfz z)i7#+af9R68~K$0x>4bM0^cc;yZ;P*L;5b$dw+WoqBF$e7EfdK&uKXcY0_q4vB7KQ zZSVf5H^^tWw=z?0Sb9Hy&NXqUh-1ljFkd9mb8M&?apsI zxm){X%eHmibi%VxLWL|lpKe@!$Q0wkCD-RDt@HM$3i+*135e2S7fZ66)Fyn+cxLQqNL8jgk01A4e%fBzReVsClPA+lP95vB-Aa`7daH#nN?v z1C0=4pa^3?ZZ?66{1_!$QDAIL?QkqGF=47G`OSdQBFB#^P8!~^WbW4Ywc8Pte>VKd>tebNKN)UC zoN$q|x}u_jK!Ah|=!k*Nkv!9QxZz+hIX2d`S>D)4FZY6Xkk#p_DJaz)rQy{*yVo*X zCVl<;?m?bzh7hKgqKHadwie#D;8}uJ;EcqsJkUJ#|La0J5Dbg~kt~w$-ZYeuka!H4 znN7Di60Sk{bN_OLKj%B94*T_LTAWq2V6GK+9mV|Rw!+@h7!XKL2= z+wff1)$w1GeUt3oGFT+`)n_zqw98nVqnLLlseQT^V!n1~h^ZRmc`YL`;;fQ^H zq!YBl$AhPACahPW4TPCPQ3vf_OctUM4d1J`r^luq<03TVq`Q^!GBV-6iWF}0rsuQ6E8c+8g@jN@UwLFPniJuF-~-d!k1Kjpn?F|uhg|K< zaC(Xr^t|*>bp&{eP5Wgy==n(Y$Nm^tM;#_S-V~o>63*4AXaFe8G_>) z4?|N)U9IWQ9l4fbju|`tyM?UUP@JRF)V1uN2_f)|Tw&nx0Ffsp!d`Bv0-g;QM2M!oI^sw1#j{b^z4{)k zJP%Ip0OSIb2+<4lpsAO^rg^aUIU;Wn@~Hu96n+!6T~OD1;yEl;8*KC4JfU%x&Ghg$ ze&*)l63ru8GXiIf4oxxqdVw#1q#)0N zvUh2Fg5cq%Y&cz}JTGBeKSr1Wx1-%S=aHtD%|>iEO(H*_@@10yp=kVsk%T zcA&ytuLUoWIZm@O(TjVtMv`l{{^cCu$UDTtG9jkqK8~od!+%MgLG-QFU zgyM5XEBHl~q=oQb0FIl+%{*=51phlIoJ{&hdn3L`WktnIy$eiYX}*xU07ChS46W@t zKaU`>Gm6lKiX4NVW-XsDo?ym_-k9h8m(6@}V{ z8W?K4k$XQp;07d~#F&pEE?Q6pc_yw0MwjdH2eE#NsU0}9-z#N^><}A7jHAskToMl`Ym&$t3izve@egUmXg>Vz_?uwxz6fKvWEXc|56|n_~P9l z$QZ^qV2weW;(f!w+1P=mtqX{##y4>!?DcB;9$iBEPNT`JV5E?)bF6X!@}PiPEkl7iJ)YRxGc!HPVCe0hXcjX5%UBU-^ zC?kSRi1pueq&7iWH{75YVt`V1choIiA1<~mwPQ~-xj09(p=y-oJ8!gZ8R@OA=z@i4 z2Ekh2N`?=OQJ(|a*siBsF3%){{~Rl4q(``KtZZg#f&WX)RFCtrILA_qK~nRt73T~h zsZ1kd*g@^r>a#8F5R7RZSFO9&MRTl(*%%CpRumk(_QBXTii&r-mMBz|aE+{o{F|{H z%FIUsOdDEb@P-N}WF1h$IRhREyu3pUV(0G7_*>Uvv`oz#3L1ULu4=QYobl3>D+aMy z0t}R(Iy>92tZAV#)hSYYUs-77jd^5b<}iUzxUk*Ry22(yxobM~C-rG+CGt;Vo|@zL z>JjL9A`xRo%OKy^)6~}KQRGoe^nIyROZAw`*!Udt%C)WocT!e$>*!Mx%4B09xd6cG1ZJ$lUgg#;T@Vmc~<<6i}w)qKZ zCQ3hCEo@V*~cvoH|&>ay%b->$9MItZdwaZIPEJfE5+2u zXFC&IPx{@BOJr)!@hVt;R#Z?(MR4ZcDM-_ki(N7$%YWm5rTFS^@b_c=?k8&hs*^VF zdGu-#ky=dON07g3uY?TepWGV3A~2vhL1|zR%BnPj=;nf}pVEl!H^XUfjdA1Aa>b_lf=`0grr1$&gyD z#h(RzWxcrH20o597`$Zr62sy4jQ?S^>6`WW4~mgzaHOgENyY3bjdg=veDmJ5{SKb! zR631-uRfVP&utU7UR}k8HXf}Sotze47)kLQ*EaPsV5y$oLf;faTFV7K)muw8^0ppI z(PhN*zgiK-?wMY#Bbp>G6sBiY`p52dM* zlGuUOcLLfE+qN2vKClrPyUp#!PLvdkv1}@0Z@rAUDknrmfFpJn3p z$y!6{;%1MG>Qkc_k{PD?WBwRyX?*b|ZJ1h}emHeXqBKG>{6YFQ#~a#w-GnyGLb{cb5NgY`Yu4 zQKnczbIy8dyyQWfGuxq<2a3Y$2P>Az>whFZ-jQ0C>AyeTRR43~Bx*S1F@09L0+sxd zJfBZKf0G!VFE5dDdLXli9hbRVqDj~1{eymFus&VuS@x=XifpGtyq6|(pA#2Z?!-*; zZJ%OkGIJaGr}o9}Cc!TtTubnd8t?wxBJrAVo8ci~&+CZ=mo1q*|HDCqg` zVh4WDH4N2nNK9K@4{o@_KR}oFz#O?4q$Fj>RTkG7H|LjQtAXH>HE2d(!~0KcjBqk1 zuG{!5pP5U>f>9PCuivENhZk|=?FtN|WmzcUC`VbvR z7jWi`s^c#OT%>y919rUOoz*|vRV@{0T4b$ANPw%qz0AW?FBwxr+;K&OkRf;3*V~G( zJ}dtI7&I07-o2yHsv)sE);(R{COevmd#=FNGS;@n>Z^*zJi>>p?xA_p{nAV?#S>l@ zypQmU?;i3wzS+2Ni}3sp!eIbYnv-7Cye;Rvq5U{FI@P_|1d4O{%;$4=Q9SJ+kOei(f@<~EnMH}bbB|=u~ER+KB+1i$)5bJ7fVW* zuH7Cwwc!+=3FfpgS4$KQ#J3QBBc_+J~6a;c|N;MCm)7OirhE$qL-BgGP$YY^QfKV z?T~-NF^(fKmIK6@Rlp7OKVSGLM+(c`|KuV_vJw^k`-lHy&*13qL@C(`5)zU~)xCV> u_Rcp<&L>Go4FCJ-zt7-*dk)HQWK*TS7c^1tkKjC!T-UszQKDuS`u_mH8LFoM From 778f93930222ffbdcf54cb1aa360632ce35043c6 Mon Sep 17 00:00:00 2001 From: eturn Date: Tue, 7 Apr 2026 03:46:45 -0400 Subject: [PATCH 027/174] fix [BUG] WebUI cannot connect to the gateway started by WebUI (#2267) #2213 --- pkg/pid/pidfile_windows.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pkg/pid/pidfile_windows.go b/pkg/pid/pidfile_windows.go index 6a2cce793..6d8b79552 100644 --- a/pkg/pid/pidfile_windows.go +++ b/pkg/pid/pidfile_windows.go @@ -23,19 +23,19 @@ func isProcessRunning(pid int) bool { return false } - handle, _, err := procOpenProcess.Call( + handle, _, _ := procOpenProcess.Call( uintptr(processQueryLimitedInformation), 0, uintptr(pid), ) - if handle == 0 || err != nil { + if handle == 0 { return false } defer procCloseHandle.Call(handle) var exitCode uint32 - ret, _, err := procGetExitCodeProcess.Call(handle, uintptr(unsafe.Pointer(&exitCode))) - if ret == 0 || err != nil { + ret, _, _ := procGetExitCodeProcess.Call(handle, uintptr(unsafe.Pointer(&exitCode))) + if ret == 0 { return false } return exitCode == stillActive From 38a498e2026613d83d5d6660ac0161b6f5df4e30 Mon Sep 17 00:00:00 2001 From: LC <64722907+lc6464@users.noreply.github.com> Date: Tue, 7 Apr 2026 16:05:21 +0800 Subject: [PATCH 028/174] feat(provider): support custom headers injection for HTTP providers (#2402) * feat(provider): support custom headers injection for HTTP providers * fix(provider): resolve lint problem * fix(provider): align stream user-agent and header precedence docs --- docs/providers.md | 1 + docs/zh/providers.md | 1 + pkg/config/config.go | 13 ++- pkg/config/config_test.go | 36 ++++++ pkg/providers/factory_provider.go | 4 + pkg/providers/factory_provider_test.go | 43 +++++++ pkg/providers/http_provider.go | 4 +- pkg/providers/openai_compat/provider.go | 21 ++++ pkg/providers/openai_compat/provider_test.go | 105 +++++++++++++++++ web/backend/api/models.go | 24 ++-- web/backend/api/models_test.go | 106 ++++++++++++++++++ web/frontend/src/api/models.ts | 1 + .../src/components/models/add-model-sheet.tsx | 17 +++ .../components/models/edit-model-sheet.tsx | 20 ++++ web/frontend/src/i18n/locales/en.json | 4 +- web/frontend/src/i18n/locales/zh.json | 4 +- 16 files changed, 389 insertions(+), 15 deletions(-) diff --git a/docs/providers.md b/docs/providers.md index 9bb95446c..d03fbab3e 100644 --- a/docs/providers.md +++ b/docs/providers.md @@ -122,6 +122,7 @@ This design also enables **multi-agent support** with flexible provider selectio | `max_tokens_field` | string | No | Override the max tokens field name in request body (e.g., `max_completion_tokens` for o1 models) | | `thinking_level` | string | No | Extended thinking level: `off`, `low`, `medium`, `high`, `xhigh`, or `adaptive` | | `extra_body` | object | No | Additional fields to inject into every request body | +| `custom_headers` | object | No | Additional HTTP headers to inject into every request (e.g., `{"X-Source":"coding-plan"}`). If a key matches a built-in header, the custom value overrides the built-in one (e.g., `Authorization`, `User-Agent`, `Content-Type`, `Accept`). | | `rpm` | int | No | Per-minute request rate limit | | `fallbacks` | string[] | No | Fallback model names for automatic failover | | `enabled` | bool | No | Whether this model entry is active (default: `true`) | diff --git a/docs/zh/providers.md b/docs/zh/providers.md index 6048b929f..7b3930f6f 100644 --- a/docs/zh/providers.md +++ b/docs/zh/providers.md @@ -118,6 +118,7 @@ | `max_tokens_field` | string | 否 | 覆盖请求体中 max tokens 的字段名（如 o1 模型使用 `max_completion_tokens`） | | `thinking_level` | string | 否 | 扩展思考级别：`off`、`low`、`medium`、`high`、`xhigh` 或 `adaptive` | | `extra_body` | object | 否 | 注入到每个请求体中的额外字段 | +| `custom_headers` | object | 否 | 注入到每个请求中的额外 HTTP 请求头（例如 `{"X-Source":"coding-plan"}`）。若键名与内置请求头同名，会覆盖内置值（如 `Authorization`、`User-Agent`、`Content-Type`、`Accept`）。 | | `rpm` | int | 否 | 每分钟请求速率限制 | | `fallbacks` | string[] | 否 | 自动故障转移的备用模型名称 | | `enabled` | bool | 否 | 是否启用此模型条目（默认：`true`） | diff --git a/pkg/config/config.go b/pkg/config/config.go index 7165246e5..1d98aa334 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -605,11 +605,12 @@ type ModelConfig struct { Workspace string `json:"workspace,omitempty"` // Workspace path for CLI-based providers // Optional optimizations - RPM int `json:"rpm,omitempty"` // Requests per minute limit - MaxTokensField string `json:"max_tokens_field,omitempty"` // Field name for max tokens (e.g., "max_completion_tokens") - RequestTimeout int `json:"request_timeout,omitempty"` - ThinkingLevel string `json:"thinking_level,omitempty"` // Extended thinking: off|low|medium|high|xhigh|adaptive - ExtraBody map[string]any `json:"extra_body,omitempty"` // Additional fields to inject into request body + RPM int `json:"rpm,omitempty"` // Requests per minute limit + MaxTokensField string `json:"max_tokens_field,omitempty"` // Field name for max tokens (e.g., "max_completion_tokens") + RequestTimeout int `json:"request_timeout,omitempty"` + ThinkingLevel string `json:"thinking_level,omitempty"` // Extended thinking: off|low|medium|high|xhigh|adaptive + ExtraBody map[string]any `json:"extra_body,omitempty"` // Additional fields to inject into request body + CustomHeaders map[string]string `json:"custom_headers,omitempty"` // Additional headers to inject into every HTTP request APIKeys SecureStrings `json:"api_keys,omitzero" yaml:"api_keys,omitempty"` // API authentication keys (multiple keys for failover) @@ -1279,6 +1280,7 @@ func expandMultiKeyModels(models []*ModelConfig) []*ModelConfig { RequestTimeout: m.RequestTimeout, ThinkingLevel: m.ThinkingLevel, ExtraBody: m.ExtraBody, + CustomHeaders: m.CustomHeaders, isVirtual: true, } expanded = append(expanded, additionalEntry) @@ -1299,6 +1301,7 @@ func expandMultiKeyModels(models []*ModelConfig) []*ModelConfig { RequestTimeout: m.RequestTimeout, ThinkingLevel: m.ThinkingLevel, ExtraBody: m.ExtraBody, + CustomHeaders: m.CustomHeaders, APIKeys: SimpleSecureStrings(keys[0]), } diff --git a/pkg/config/config_test.go b/pkg/config/config_test.go index 8e58a684e..1c6b784c7 100644 --- a/pkg/config/config_test.go +++ b/pkg/config/config_test.go @@ -1528,6 +1528,42 @@ func TestModelConfig_ExtraBodyRoundTrip(t *testing.T) { } } +func TestModelConfig_CustomHeadersRoundTrip(t *testing.T) { + dir := t.TempDir() + cfgPath := filepath.Join(dir, "config.json") + + cfg := &Config{ + Version: CurrentVersion, + ModelList: []*ModelConfig{ + { + ModelName: "test-model", + Model: "openai/test", + APIKeys: SimpleSecureStrings("sk-test"), + CustomHeaders: map[string]string{"X-Source": "coding-plan", "X-Agent": "openclaw"}, + }, + }, + } + + if err := SaveConfig(cfgPath, cfg); err != nil { + t.Fatalf("SaveConfig error: %v", err) + } + + loaded, err := LoadConfig(cfgPath) + if err != nil { + t.Fatalf("LoadConfig error: %v", err) + } + + if loaded.ModelList[0].CustomHeaders == nil { + t.Fatal("CustomHeaders should not be nil after round-trip") + } + if got := loaded.ModelList[0].CustomHeaders["X-Source"]; got != "coding-plan" { + t.Errorf("CustomHeaders[X-Source] = %q, want coding-plan", got) + } + if got := loaded.ModelList[0].CustomHeaders["X-Agent"]; got != "openclaw" { + t.Errorf("CustomHeaders[X-Agent] = %q, want openclaw", got) + } +} + func TestDefaultConfig_MinimaxExtraBody(t *testing.T) { cfg := DefaultConfig() diff --git a/pkg/providers/factory_provider.go b/pkg/providers/factory_provider.go index ab7277fae..f13dc646c 100644 --- a/pkg/providers/factory_provider.go +++ b/pkg/providers/factory_provider.go @@ -160,6 +160,7 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err userAgent, cfg.RequestTimeout, cfg.ExtraBody, + cfg.CustomHeaders, ), modelID, nil case "azure", "azure-openai": @@ -238,6 +239,7 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err userAgent, cfg.RequestTimeout, cfg.ExtraBody, + cfg.CustomHeaders, ), modelID, nil case "minimax": @@ -264,6 +266,7 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err userAgent, cfg.RequestTimeout, extraBody, + cfg.CustomHeaders, ), modelID, nil case "anthropic": @@ -291,6 +294,7 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err userAgent, cfg.RequestTimeout, cfg.ExtraBody, + cfg.CustomHeaders, ), modelID, nil case "anthropic-messages": diff --git a/pkg/providers/factory_provider_test.go b/pkg/providers/factory_provider_test.go index b4f672f7a..c362463ae 100644 --- a/pkg/providers/factory_provider_test.go +++ b/pkg/providers/factory_provider_test.go @@ -846,6 +846,49 @@ func TestCreateProviderFromConfig_MinimaxPreservesUserExtraBody(t *testing.T) { } } +func TestCreateProviderFromConfig_CustomHeaders(t *testing.T) { + var gotSource, gotAuth string + + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + gotSource = r.Header.Get("X-Source") + gotAuth = r.Header.Get("Authorization") + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{"choices":[{"message":{"content":"ok"},"finish_reason":"stop"}]}`)) + })) + defer server.Close() + + cfg := &config.ModelConfig{ + ModelName: "test-headers", + Model: "openai/gpt-4o", + APIBase: server.URL, + CustomHeaders: map[string]string{"X-Source": "coding-plan", "Authorization": "Token config-auth"}, + } + cfg.SetAPIKey("test-key") + + provider, modelID, err := CreateProviderFromConfig(cfg) + if err != nil { + t.Fatalf("CreateProviderFromConfig() error = %v", err) + } + + _, err = provider.Chat( + t.Context(), + []Message{{Role: "user", Content: "hi"}}, + nil, + modelID, + nil, + ) + if err != nil { + t.Fatalf("Chat() error = %v", err) + } + + if gotSource != "coding-plan" { + t.Fatalf("X-Source = %q, want %q", gotSource, "coding-plan") + } + if gotAuth != "Token config-auth" { + t.Fatalf("Authorization = %q, want %q", gotAuth, "Token config-auth") + } +} + // openaiCompatResponse is the JSON response used by OpenAI-compatible providers. const openaiCompatResponse = `{"choices":[{"message":{"content":"ok"},"finish_reason":"stop"}]}` diff --git a/pkg/providers/http_provider.go b/pkg/providers/http_provider.go index dae730536..ac91f15f6 100644 --- a/pkg/providers/http_provider.go +++ b/pkg/providers/http_provider.go @@ -24,13 +24,14 @@ func NewHTTPProvider(apiKey, apiBase, proxy string) *HTTPProvider { } func NewHTTPProviderWithMaxTokensField(apiKey, apiBase, proxy, maxTokensField string) *HTTPProvider { - return NewHTTPProviderWithMaxTokensFieldAndRequestTimeout(apiKey, apiBase, proxy, maxTokensField, "", 0, nil) + return NewHTTPProviderWithMaxTokensFieldAndRequestTimeout(apiKey, apiBase, proxy, maxTokensField, "", 0, nil, nil) } func NewHTTPProviderWithMaxTokensFieldAndRequestTimeout( apiKey, apiBase, proxy, maxTokensField, userAgent string, requestTimeoutSeconds int, extraBody map[string]any, + customHeaders map[string]string, ) *HTTPProvider { return &HTTPProvider{ delegate: openai_compat.NewProvider( @@ -40,6 +41,7 @@ func NewHTTPProviderWithMaxTokensFieldAndRequestTimeout( openai_compat.WithMaxTokensField(maxTokensField), openai_compat.WithRequestTimeout(time.Duration(requestTimeoutSeconds)*time.Second), openai_compat.WithExtraBody(extraBody), + openai_compat.WithCustomHeaders(customHeaders), openai_compat.WithUserAgent(userAgent), ), } diff --git a/pkg/providers/openai_compat/provider.go b/pkg/providers/openai_compat/provider.go index 7cda033ad..d25a0fce4 100644 --- a/pkg/providers/openai_compat/provider.go +++ b/pkg/providers/openai_compat/provider.go @@ -36,6 +36,7 @@ type Provider struct { maxTokensField string // Field name for max tokens (e.g., "max_completion_tokens" for o1/glm models) httpClient *http.Client extraBody map[string]any // Additional fields to inject into request body + customHeaders map[string]string userAgent string } @@ -87,6 +88,12 @@ func WithExtraBody(extraBody map[string]any) Option { } } +func WithCustomHeaders(customHeaders map[string]string) Option { + return func(p *Provider) { + p.customHeaders = customHeaders + } +} + func NewProvider(apiKey, apiBase, proxy string, opts ...Option) *Provider { p := &Provider{ apiKey: apiKey, @@ -181,6 +188,15 @@ func (p *Provider) buildRequestBody( return requestBody } +func (p *Provider) applyCustomHeaders(req *http.Request) { + for k, v := range p.customHeaders { + if strings.TrimSpace(k) == "" { + continue + } + req.Header.Set(k, v) + } +} + func (p *Provider) Chat( ctx context.Context, messages []Message, @@ -211,6 +227,7 @@ func (p *Provider) Chat( if p.apiKey != "" { req.Header.Set("Authorization", "Bearer "+p.apiKey) } + p.applyCustomHeaders(req) resp, err := p.httpClient.Do(req) if err != nil { @@ -254,9 +271,13 @@ func (p *Provider) ChatStream( req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "text/event-stream") + if p.userAgent != "" { + req.Header.Set("User-Agent", p.userAgent) + } if p.apiKey != "" { req.Header.Set("Authorization", "Bearer "+p.apiKey) } + p.applyCustomHeaders(req) // Use a client without Timeout for streaming — the http.Client.Timeout covers // the entire request lifecycle including body reads, which would kill long streams. diff --git a/pkg/providers/openai_compat/provider_test.go b/pkg/providers/openai_compat/provider_test.go index 30aa76eb3..d140d63d6 100644 --- a/pkg/providers/openai_compat/provider_test.go +++ b/pkg/providers/openai_compat/provider_test.go @@ -710,6 +710,111 @@ func TestProviderChat_ExtraBodyOverridesOptions(t *testing.T) { } } +func TestProviderChat_CustomHeadersInjected(t *testing.T) { + var gotSource, gotAuth, gotUserAgent string + + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + gotSource = r.Header.Get("X-Source") + gotAuth = r.Header.Get("Authorization") + gotUserAgent = r.Header.Get("User-Agent") + resp := map[string]any{ + "choices": []map[string]any{ + { + "message": map[string]any{"content": "ok"}, + "finish_reason": "stop", + }, + }, + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(resp) + })) + defer server.Close() + + p := NewProvider( + "key", + server.URL, + "", + WithUserAgent("PicoClaw/Test"), + WithCustomHeaders(map[string]string{ + "X-Source": "coding-plan", + "Authorization": "Token custom-auth", + "User-Agent": "Custom-UA/1.0", + }), + ) + + _, err := p.Chat( + t.Context(), + []Message{{Role: "user", Content: "hi"}}, + nil, + "gpt-4o", + nil, + ) + if err != nil { + t.Fatalf("Chat() error = %v", err) + } + + if gotSource != "coding-plan" { + t.Fatalf("X-Source = %q, want %q", gotSource, "coding-plan") + } + if gotAuth != "Token custom-auth" { + t.Fatalf("Authorization = %q, want %q", gotAuth, "Token custom-auth") + } + if gotUserAgent != "Custom-UA/1.0" { + t.Fatalf("User-Agent = %q, want %q", gotUserAgent, "Custom-UA/1.0") + } +} + +func TestProviderChatStream_CustomHeadersInjected(t *testing.T) { + var gotSource, gotAuth, gotUserAgent string + + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + gotSource = r.Header.Get("X-Source") + gotAuth = r.Header.Get("Authorization") + gotUserAgent = r.Header.Get("User-Agent") + + w.Header().Set("Content-Type", "text/event-stream") + _, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"ok\"},\"finish_reason\":\"stop\"}]}\n\n")) + _, _ = w.Write([]byte("data: [DONE]\n\n")) + })) + defer server.Close() + + p := NewProvider( + "key", + server.URL, + "", + WithUserAgent("PicoClaw/Test"), + WithCustomHeaders(map[string]string{ + "X-Source": "coding-plan", + "Authorization": "Token stream-auth", + "User-Agent": "Custom-UA/Stream", + }), + ) + + out, err := p.ChatStream( + t.Context(), + []Message{{Role: "user", Content: "hi"}}, + nil, + "gpt-4o", + nil, + nil, + ) + if err != nil { + t.Fatalf("ChatStream() error = %v", err) + } + if out.Content != "ok" { + t.Fatalf("Content = %q, want %q", out.Content, "ok") + } + if gotSource != "coding-plan" { + t.Fatalf("X-Source = %q, want %q", gotSource, "coding-plan") + } + if gotAuth != "Token stream-auth" { + t.Fatalf("Authorization = %q, want %q", gotAuth, "Token stream-auth") + } + if gotUserAgent != "Custom-UA/Stream" { + t.Fatalf("User-Agent = %q, want %q", gotUserAgent, "Custom-UA/Stream") + } +} + type roundTripperFunc func(*http.Request) (*http.Response, error) func (f roundTripperFunc) RoundTrip(r *http.Request) (*http.Response, error) { diff --git a/web/backend/api/models.go b/web/backend/api/models.go index e6749b56e..aa4a775eb 100644 --- a/web/backend/api/models.go +++ b/web/backend/api/models.go @@ -32,13 +32,14 @@ type modelResponse struct { Proxy string `json:"proxy,omitempty"` AuthMethod string `json:"auth_method,omitempty"` // Advanced fields - ConnectMode string `json:"connect_mode,omitempty"` - Workspace string `json:"workspace,omitempty"` - RPM int `json:"rpm,omitempty"` - MaxTokensField string `json:"max_tokens_field,omitempty"` - RequestTimeout int `json:"request_timeout,omitempty"` - ThinkingLevel string `json:"thinking_level,omitempty"` - ExtraBody map[string]any `json:"extra_body,omitempty"` + ConnectMode string `json:"connect_mode,omitempty"` + Workspace string `json:"workspace,omitempty"` + RPM int `json:"rpm,omitempty"` + MaxTokensField string `json:"max_tokens_field,omitempty"` + RequestTimeout int `json:"request_timeout,omitempty"` + ThinkingLevel string `json:"thinking_level,omitempty"` + ExtraBody map[string]any `json:"extra_body,omitempty"` + CustomHeaders map[string]string `json:"custom_headers,omitempty"` // Meta Enabled bool `json:"enabled"` Available bool `json:"available"` @@ -87,6 +88,7 @@ func (h *Handler) handleListModels(w http.ResponseWriter, r *http.Request) { RequestTimeout: m.RequestTimeout, ThinkingLevel: m.ThinkingLevel, ExtraBody: m.ExtraBody, + CustomHeaders: m.CustomHeaders, Enabled: m.Enabled, Available: modelStatuses[i].Available, Status: modelStatuses[i].Status, @@ -216,6 +218,14 @@ func (h *Handler) handleUpdateModel(w http.ResponseWriter, r *http.Request) { } else if len(mc.ExtraBody) == 0 { mc.ExtraBody = nil } + // Preserve existing CustomHeaders when omitted (nil), but clear it when + // the frontend sends an empty object {} to indicate the field should + // be removed. + if mc.CustomHeaders == nil { + mc.CustomHeaders = cfg.ModelList[idx].CustomHeaders + } else if len(mc.CustomHeaders) == 0 { + mc.CustomHeaders = nil + } cfg.ModelList[idx] = &mc.ModelConfig diff --git a/web/backend/api/models_test.go b/web/backend/api/models_test.go index e54d5b77c..e4297f679 100644 --- a/web/backend/api/models_test.go +++ b/web/backend/api/models_test.go @@ -430,6 +430,112 @@ func TestHandleAddModel_PersistsAPIKey(t *testing.T) { } } +func TestHandleAddModel_PersistsCustomHeaders(t *testing.T) { + configPath, cleanup := setupOAuthTestEnv(t) + defer cleanup() + + h := NewHandler(configPath) + mux := http.NewServeMux() + h.RegisterRoutes(mux) + + rec := httptest.NewRecorder() + req := httptest.NewRequest(http.MethodPost, "/api/models", bytes.NewBufferString(`{ + "model_name":"new-model-headers", + "model":"openai/gpt-4o-mini", + "custom_headers":{"X-Source":"coding-plan","X-Agent":"openclaw"} + }`)) + req.Header.Set("Content-Type", "application/json") + mux.ServeHTTP(rec, req) + + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want %d, body=%s", rec.Code, http.StatusOK, rec.Body.String()) + } + + cfg, err := config.LoadConfig(configPath) + if err != nil { + t.Fatalf("LoadConfig() error = %v", err) + } + if len(cfg.ModelList) != 2 { + t.Fatalf("len(model_list) = %d, want 2", len(cfg.ModelList)) + } + + added := cfg.ModelList[1] + if added.CustomHeaders == nil { + t.Fatal("custom_headers should not be nil") + } + if got := added.CustomHeaders["X-Source"]; got != "coding-plan" { + t.Fatalf("custom_headers[X-Source] = %q, want %q", got, "coding-plan") + } + if got := added.CustomHeaders["X-Agent"]; got != "openclaw" { + t.Fatalf("custom_headers[X-Agent] = %q, want %q", got, "openclaw") + } +} + +func TestHandleUpdateModel_CustomHeadersPreserveAndClear(t *testing.T) { + configPath, cleanup := setupOAuthTestEnv(t) + defer cleanup() + + cfg, err := config.LoadConfig(configPath) + if err != nil { + t.Fatalf("LoadConfig() error = %v", err) + } + cfg.ModelList = []*config.ModelConfig{{ + ModelName: "editable", + Model: "openai/gpt-4o-mini", + APIKeys: config.SimpleSecureStrings("sk-existing"), + CustomHeaders: map[string]string{"X-Source": "coding-plan"}, + }} + err = config.SaveConfig(configPath, cfg) + if err != nil { + t.Fatalf("SaveConfig() error = %v", err) + } + + h := NewHandler(configPath) + mux := http.NewServeMux() + h.RegisterRoutes(mux) + + // Omitted custom_headers should preserve existing value. + recPreserve := httptest.NewRecorder() + reqPreserve := httptest.NewRequest(http.MethodPut, "/api/models/0", bytes.NewBufferString(`{ + "model_name":"editable", + "model":"openai/gpt-4o-mini" + }`)) + reqPreserve.Header.Set("Content-Type", "application/json") + mux.ServeHTTP(recPreserve, reqPreserve) + if recPreserve.Code != http.StatusOK { + t.Fatalf("preserve status = %d, want %d, body=%s", recPreserve.Code, http.StatusOK, recPreserve.Body.String()) + } + + afterPreserve, err := config.LoadConfig(configPath) + if err != nil { + t.Fatalf("LoadConfig() after preserve error = %v", err) + } + if got := afterPreserve.ModelList[0].CustomHeaders["X-Source"]; got != "coding-plan" { + t.Fatalf("preserved custom_headers[X-Source] = %q, want %q", got, "coding-plan") + } + + // Empty object should clear custom_headers. + recClear := httptest.NewRecorder() + reqClear := httptest.NewRequest(http.MethodPut, "/api/models/0", bytes.NewBufferString(`{ + "model_name":"editable", + "model":"openai/gpt-4o-mini", + "custom_headers":{} + }`)) + reqClear.Header.Set("Content-Type", "application/json") + mux.ServeHTTP(recClear, reqClear) + if recClear.Code != http.StatusOK { + t.Fatalf("clear status = %d, want %d, body=%s", recClear.Code, http.StatusOK, recClear.Body.String()) + } + + afterClear, err := config.LoadConfig(configPath) + if err != nil { + t.Fatalf("LoadConfig() after clear error = %v", err) + } + if afterClear.ModelList[0].CustomHeaders != nil { + t.Fatalf("custom_headers = %#v, want nil", afterClear.ModelList[0].CustomHeaders) + } +} + // TestHandleSetDefaultModel_RejectsNonexistentModel tests that setting a non-existent // model as default returns 404. This covers the case where virtual models (which are // filtered by SaveConfig) cannot be set as default. diff --git a/web/frontend/src/api/models.ts b/web/frontend/src/api/models.ts index eb8d287dd..bfdd80d6d 100644 --- a/web/frontend/src/api/models.ts +++ b/web/frontend/src/api/models.ts @@ -19,6 +19,7 @@ export interface ModelInfo { request_timeout?: number thinking_level?: string extra_body?: Record + custom_headers?: Record // Meta available: boolean status: "available" | "unconfigured" | "unreachable" diff --git a/web/frontend/src/components/models/add-model-sheet.tsx b/web/frontend/src/components/models/add-model-sheet.tsx index de9481391..dfbcd4b13 100644 --- a/web/frontend/src/components/models/add-model-sheet.tsx +++ b/web/frontend/src/components/models/add-model-sheet.tsx @@ -36,6 +36,7 @@ interface AddForm { requestTimeout: string thinkingLevel: string extraBody: string + customHeaders: string } const EMPTY_ADD_FORM: AddForm = { @@ -52,6 +53,7 @@ const EMPTY_ADD_FORM: AddForm = { requestTimeout: "", thinkingLevel: "", extraBody: "", + customHeaders: "", } interface AddModelSheetProps { @@ -136,6 +138,9 @@ export function AddModelSheet({ extra_body: form.extraBody.trim() ? JSON.parse(form.extraBody.trim()) : undefined, + custom_headers: form.customHeaders.trim() + ? JSON.parse(form.customHeaders.trim()) + : undefined, }) if (setAsDefault) { await setDefaultModel(modelName) @@ -324,6 +329,18 @@ export function AddModelSheet({ rows={3} /> + + +