mirror of
https://github.com/tiennm99/goclaw.git
synced 2026-10-11 03:13:24 +00:00
yatulandClaude Opus 5
0e3eb57317
* feat(delegate): add action=list, scoped to the originating chat Fixes #1545. A delegation result was addressable only by the UUID returned once in a tool result, which the calling model had to carry forward by hand. One mistyped character orphaned a completed, durably stored result with no way back: `get` answers "delegation result not found", and there was nothing else to ask. Observed in production with a 31B-class caller — one flipped character, and separately a splice of the previous delegation's tail onto the next one's prefix. `spawn`, the sibling async mechanism over the same table, has had list/wait/cancel all along; `delegate` had delegate/get. Scope is tenant and calling agent, as get already resolves, plus the origin chat. The chat rather than the session, for three reasons: - It survives a session reset. Deferring long work, clearing the context and coming back to ask for status is ordinary use; a SessionKey predicate would return nothing exactly then — when the handle is most likely already lost. - It keeps chats apart, which is the enumeration boundary #1525 is about: there spawn's list filters on the parent agent key alone and ignores the session, so one chat reads another chat's task text. - It does not carry a conversation between chats. A delegation raised in a team chat stays visible in that team chat and does not surface in someone's DM with the same agent. History stays where it began. In a direct chat that separates users as well, since the chat ID is per person. Group chats deliberately show the group what the group started. get is left as it was, deliberately. #1525 is an enumeration defect — no prior knowledge needed and task text is disclosed. get is access through an unguessable handle, and adding a predicate there would break fetching a result by an ID kept across a reset, which is the very failure this fixes. No schema change: the origin fields are already persisted by createDelegateCompletion. ListByParent is filtered in Go behind a cap of 20, which suits handle recovery; a dedicated predicate would be the next step if this ever needs to page. Tests pin the chat boundary, the session-reset case, refusal when there is no chat to scope to (without querying the store), and the cap. The fake store leaves ListBySession embedded and nil, so a refactor back to session scoping panics rather than passing quietly. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(delegate): list needs its own store query — ListByParent excludes delegations The action shipped in 506ecba4 always returned an empty list. It read through SubagentTaskStore.ListByParent, whose SQL carries AND COALESCE(metadata->>'completion_kind', 'subagent') <> 'delegate' ListBySession carries the same clause. Both serve spawn and filter delegations out on purpose, so no listing in the store could return one — only Get by ID reaches a delegation. The feature was a no-op in production while its unit tests were green, because the fake store returned whatever rows the fixture supplied and never reproduced the predicate that does the damage. Found by running it against a live cluster: an async delegation was created, `get` returned it completed with its result, and `list` reported zero. Adds ListDelegationsByChat to the interface and to both implementations, with the inverse predicate plus origin_chat_id, and points the tool at it. Chat scope and delegate-only selection now live in the query rather than in a Go filter over whatever the store happened to return; an empty chat yields no rows instead of falling back to everything. Tests are where the fix matters most: - internal/store/sqlitestore exercises the real SQL. It pins that ListDelegationsByChat returns the chat's delegation, that a spawn in the same chat is not one, that another tenant's identically named chat stays invisible, and — the part that would have caught this — that ListByParent and ListBySession still do not return delegations, so the complementarity is documented rather than assumed. - the tool's fake now panics if ListByParent or ListBySession is called, so a regression to either fails loudly instead of quietly listing nothing, and it applies the chat and kind predicates itself so fixtures behave like the store. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
93 lines
2.8 KiB
Go
93 lines
2.8 KiB
Go
package cmd
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"github.com/nextlevelbuilder/goclaw/internal/bus"
|
|
"github.com/nextlevelbuilder/goclaw/internal/store"
|
|
"github.com/nextlevelbuilder/goclaw/internal/tools"
|
|
)
|
|
|
|
type recordingGatewayTaskStore struct {
|
|
metadata chan map[string]any
|
|
}
|
|
|
|
func (*recordingGatewayTaskStore) Create(context.Context, *store.SubagentTaskData) error {
|
|
return nil
|
|
}
|
|
func (*recordingGatewayTaskStore) Get(context.Context, uuid.UUID, uuid.UUID) (*store.SubagentTaskData, error) {
|
|
return nil, nil
|
|
}
|
|
func (*recordingGatewayTaskStore) UpdateStatus(context.Context, uuid.UUID, uuid.UUID, string, *string, int, int64, int64) error {
|
|
return nil
|
|
}
|
|
func (*recordingGatewayTaskStore) ListDelegationsByChat(context.Context, uuid.UUID, string) ([]store.SubagentTaskData, error) {
|
|
return nil, nil
|
|
}
|
|
func (*recordingGatewayTaskStore) ListByParent(context.Context, uuid.UUID, string) ([]store.SubagentTaskData, error) {
|
|
return nil, nil
|
|
}
|
|
func (*recordingGatewayTaskStore) ListBySession(context.Context, uuid.UUID, string) ([]store.SubagentTaskData, error) {
|
|
return nil, nil
|
|
}
|
|
func (*recordingGatewayTaskStore) Archive(context.Context, uuid.UUID, time.Duration, int) (int64, error) {
|
|
return 0, nil
|
|
}
|
|
func (s *recordingGatewayTaskStore) UpdateMetadata(_ context.Context, _ uuid.UUID, _ uuid.UUID, metadata map[string]any) error {
|
|
s.metadata <- metadata
|
|
return nil
|
|
}
|
|
|
|
func TestSubagentBatchAnnouncementDoesNotBlockOnFullInboundBus(t *testing.T) {
|
|
messageBus := bus.New()
|
|
for range 1000 {
|
|
messageBus.PublishInbound(bus.InboundMessage{Content: "fill"})
|
|
}
|
|
manager := tools.NewSubagentManager(nil, nil, "", messageBus, nil, tools.SubagentConfig{})
|
|
taskStore := &recordingGatewayTaskStore{metadata: make(chan map[string]any, 1)}
|
|
manager.SetTaskStore(taskStore)
|
|
callback := makeDelegateAnnounceCallback(manager, messageBus)
|
|
completionID := uuid.New()
|
|
|
|
done := make(chan struct{})
|
|
go func() {
|
|
callback(
|
|
"session-1",
|
|
[]tools.AnnounceQueueItem{{
|
|
SubagentID: "task-1",
|
|
CompletionID: completionID,
|
|
DurablyPersisted: true,
|
|
Label: "probe",
|
|
Status: tools.TaskStatusCompleted,
|
|
Result: "done",
|
|
}},
|
|
tools.AnnounceMetadata{
|
|
OriginChatID: "chat-1",
|
|
OriginSessionKey: "session-1",
|
|
OriginTenantID: uuid.New(),
|
|
RootAgentID: uuid.New(),
|
|
ParentAgent: "root",
|
|
},
|
|
)
|
|
close(done)
|
|
}()
|
|
|
|
select {
|
|
case <-done:
|
|
case <-time.After(time.Second):
|
|
t.Fatal("batched subagent announcement blocked on a full inbound bus")
|
|
}
|
|
select {
|
|
case metadata := <-taskStore.metadata:
|
|
if metadata["announcement_status"] != "undelivered" {
|
|
t.Fatalf("announcement metadata = %#v, want undelivered", metadata)
|
|
}
|
|
case <-time.After(time.Second):
|
|
t.Fatal("batched missed announcement was not recorded after bus saturation")
|
|
}
|
|
}
|