mirror of
https://github.com/tiennm99/goclaw.git
synced 2026-07-25 08:18:56 +00:00
259 lines
9.1 KiB
Go
259 lines
9.1 KiB
Go
package agent
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
"testing"
|
|
|
|
"github.com/nextlevelbuilder/goclaw/internal/config"
|
|
"github.com/nextlevelbuilder/goclaw/internal/pipeline"
|
|
"github.com/nextlevelbuilder/goclaw/internal/providers"
|
|
"github.com/nextlevelbuilder/goclaw/internal/tools"
|
|
"github.com/nextlevelbuilder/goclaw/pkg/protocol"
|
|
)
|
|
|
|
// stubExecutor implements tools.ToolExecutor with a canned successful Result.
|
|
// Used to isolate the tool-callback wrappers from real tool registry wiring.
|
|
type stubExecutor struct{}
|
|
|
|
func (s *stubExecutor) ExecuteWithContext(_ context.Context, _ string, _ map[string]any, _, _, _, _ string, _ tools.AsyncCallback) *tools.Result {
|
|
return &tools.Result{ForLLM: "ok", IsError: false}
|
|
}
|
|
func (s *stubExecutor) TryActivateDeferred(string) bool { return false }
|
|
func (s *stubExecutor) ProviderDefs() []providers.ToolDefinition { return nil }
|
|
func (s *stubExecutor) Get(string) (tools.Tool, bool) { return nil, false }
|
|
func (s *stubExecutor) List() []string { return nil }
|
|
func (s *stubExecutor) Aliases() map[string]string { return nil }
|
|
|
|
type metadataTestTool struct {
|
|
name string
|
|
}
|
|
|
|
func (t metadataTestTool) Name() string { return t.name }
|
|
func (t metadataTestTool) Description() string { return "test tool" }
|
|
func (t metadataTestTool) Parameters() map[string]any { return nil }
|
|
func (t metadataTestTool) Execute(context.Context, map[string]any) *tools.Result {
|
|
return &tools.Result{ForLLM: "ok"}
|
|
}
|
|
|
|
// eventCollector buffers AgentEvents for inspection in tests.
|
|
// Safe for concurrent appends from parallel goroutines.
|
|
type eventCollector struct {
|
|
mu sync.Mutex
|
|
events []AgentEvent
|
|
}
|
|
|
|
func (c *eventCollector) onEvent(e AgentEvent) {
|
|
c.mu.Lock()
|
|
c.events = append(c.events, e)
|
|
c.mu.Unlock()
|
|
}
|
|
|
|
func (c *eventCollector) filter(typ string) []AgentEvent {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
var out []AgentEvent
|
|
for _, e := range c.events {
|
|
if e.Type == typ {
|
|
out = append(out, e)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// newTestLoopForToolCallbacks builds a minimal Loop instance sufficient to
|
|
// exercise makeExecuteToolCall / makeExecuteToolRaw. All optional subsystems
|
|
// (tracing, metrics, input guard) are left nil and hit early-return paths.
|
|
func newTestLoopForToolCallbacks(onEvent func(AgentEvent)) *Loop {
|
|
return &Loop{
|
|
id: "test-agent",
|
|
tools: &stubExecutor{},
|
|
onEvent: onEvent,
|
|
}
|
|
}
|
|
|
|
// TestMakeExecuteToolCall_EmitsToolCallEvent verifies the sequential wrapper
|
|
// emits a tool.call event before running tool I/O.
|
|
func TestMakeExecuteToolCall_EmitsToolCallEvent(t *testing.T) {
|
|
t.Parallel()
|
|
col := &eventCollector{}
|
|
l := newTestLoopForToolCallbacks(col.onEvent)
|
|
|
|
req := &RunRequest{
|
|
RunID: "run-1",
|
|
SessionKey: "sess-A",
|
|
UserID: "u-1",
|
|
SenderID: "sender-1",
|
|
Channel: "ws",
|
|
RunKind: "",
|
|
}
|
|
state := &pipeline.RunState{RunID: "run-1"}
|
|
tc := providers.ToolCall{ID: "tc-1", Name: "read_file", Arguments: map[string]any{"path": "/tmp/x"}}
|
|
|
|
_, err := l.makeExecuteToolCall(req, &runState{})(context.Background(), state, tc)
|
|
if err != nil {
|
|
t.Fatalf("makeExecuteToolCall returned error: %v", err)
|
|
}
|
|
|
|
calls := col.filter(protocol.AgentEventToolCall)
|
|
if len(calls) != 1 {
|
|
t.Fatalf("expected 1 tool.call event, got %d (all events: %+v)", len(calls), col.events)
|
|
}
|
|
assertToolCallPayload(t, calls[0], tc, req)
|
|
}
|
|
|
|
// TestMakeExecuteToolRaw_EmitsToolCallEvent is the PRIMARY regression guard.
|
|
// The original bug: parallel path (makeExecuteToolRaw) did not emit tool.call,
|
|
// so web UI and desktop UI silently dropped tool info during real-time streaming.
|
|
// Mutation-verify: remove emitRun(...) from makeExecuteToolRaw — this test must fail.
|
|
func TestMakeExecuteToolRaw_EmitsToolCallEvent(t *testing.T) {
|
|
t.Parallel()
|
|
col := &eventCollector{}
|
|
l := newTestLoopForToolCallbacks(col.onEvent)
|
|
|
|
req := &RunRequest{
|
|
RunID: "run-2",
|
|
SessionKey: "sess-B",
|
|
UserID: "u-2",
|
|
SenderID: "sender-2",
|
|
Channel: "ws",
|
|
RunKind: "",
|
|
}
|
|
tc := providers.ToolCall{ID: "tc-2", Name: "write_file", Arguments: map[string]any{"path": "/tmp/y"}}
|
|
|
|
msg, raw, err := l.makeExecuteToolRaw(req)(context.Background(), tc)
|
|
if err != nil {
|
|
t.Fatalf("makeExecuteToolRaw returned error: %v", err)
|
|
}
|
|
if msg.Role != "tool" || msg.ToolCallID != tc.ID {
|
|
t.Errorf("unexpected tool message: %+v", msg)
|
|
}
|
|
if raw == nil {
|
|
t.Error("expected non-nil raw data (toolRawResult)")
|
|
}
|
|
|
|
calls := col.filter(protocol.AgentEventToolCall)
|
|
if len(calls) != 1 {
|
|
t.Fatalf("expected 1 tool.call event, got %d (all events: %+v)", len(calls), col.events)
|
|
}
|
|
assertToolCallPayload(t, calls[0], tc, req)
|
|
}
|
|
|
|
// TestMakeExecuteToolRaw_ConcurrentCallsEmitAllEvents confirms the parallel
|
|
// wrapper is safe to invoke from multiple goroutines — mirrors the real
|
|
// executeParallel dispatch in pipeline/tool_stage.go.
|
|
func TestMakeExecuteToolRaw_ConcurrentCallsEmitAllEvents(t *testing.T) {
|
|
t.Parallel()
|
|
col := &eventCollector{}
|
|
l := newTestLoopForToolCallbacks(col.onEvent)
|
|
|
|
req := &RunRequest{RunID: "run-3", SessionKey: "sess-C", UserID: "u-3", SenderID: "sender-3", Channel: "ws"}
|
|
exec := l.makeExecuteToolRaw(req)
|
|
|
|
const n = 5
|
|
var wg sync.WaitGroup
|
|
for i := range n {
|
|
wg.Add(1)
|
|
go func(idx int) {
|
|
defer wg.Done()
|
|
tc := providers.ToolCall{ID: "tc-" + string(rune('a'+idx)), Name: "t", Arguments: nil}
|
|
if _, _, err := exec(context.Background(), tc); err != nil {
|
|
t.Errorf("goroutine %d: %v", idx, err)
|
|
}
|
|
}(i)
|
|
}
|
|
wg.Wait()
|
|
|
|
calls := col.filter(protocol.AgentEventToolCall)
|
|
if len(calls) != n {
|
|
t.Fatalf("expected %d tool.call events, got %d", n, len(calls))
|
|
}
|
|
}
|
|
|
|
func TestParallelEligibleToolCall_OnlyAllowsRegisteredReadOnlyTools(t *testing.T) {
|
|
t.Parallel()
|
|
registry := tools.NewRegistry()
|
|
registry.RegisterWithMetadata(metadataTestTool{name: "read_file"}, tools.ToolMetadata{Capabilities: []tools.ToolCapability{tools.CapReadOnly}})
|
|
registry.RegisterWithMetadata(metadataTestTool{name: "write_file"}, tools.ToolMetadata{Capabilities: []tools.ToolCapability{tools.CapMutating}})
|
|
registry.RegisterWithMetadata(metadataTestTool{name: "spawn"}, tools.ToolMetadata{Capabilities: []tools.ToolCapability{tools.CapAsync}})
|
|
registry.RegisterWithMetadata(metadataTestTool{name: "mcp_search"}, tools.ToolMetadata{Capabilities: []tools.ToolCapability{tools.CapReadOnly, tools.CapMCPBridged}})
|
|
registry.RegisterWithMetadata(metadataTestTool{name: "web_fetch"}, tools.ToolMetadata{Capabilities: []tools.ToolCapability{tools.CapReadOnly}})
|
|
registry.RegisterAlias("read_alias", "read_file")
|
|
|
|
l := &Loop{registry: registry}
|
|
|
|
tests := []struct {
|
|
name string
|
|
tc providers.ToolCall
|
|
want bool
|
|
}{
|
|
{name: "registered read only", tc: providers.ToolCall{Name: "read_file"}, want: true},
|
|
{name: "alias read only", tc: providers.ToolCall{Name: "read_alias"}, want: true},
|
|
{name: "mutating", tc: providers.ToolCall{Name: "write_file"}, want: false},
|
|
{name: "async", tc: providers.ToolCall{Name: "spawn"}, want: false},
|
|
{name: "mcp prefix", tc: providers.ToolCall{Name: "mcp_search"}, want: false},
|
|
{name: "exec excluded", tc: providers.ToolCall{Name: "exec"}, want: false},
|
|
{name: "wait excluded", tc: providers.ToolCall{Name: "wait"}, want: false},
|
|
{name: "unknown inferred read only still blocked", tc: providers.ToolCall{Name: "web_search"}, want: false},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
if got := l.parallelEligibleToolCall(tt.tc); got != tt.want {
|
|
t.Fatalf("parallelEligibleToolCall(%q) = %v, want %v", tt.tc.Name, got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestParallelEligibleToolCall_StripsAgentToolPrefixBeforeMetadataLookup(t *testing.T) {
|
|
t.Parallel()
|
|
registry := tools.NewRegistry()
|
|
registry.RegisterWithMetadata(metadataTestTool{name: "web_fetch"}, tools.ToolMetadata{Capabilities: []tools.ToolCapability{tools.CapReadOnly}})
|
|
|
|
l := &Loop{
|
|
registry: registry,
|
|
agentToolPolicy: &config.ToolPolicySpec{
|
|
ToolCallPrefix: "agent_",
|
|
},
|
|
}
|
|
|
|
if !l.parallelEligibleToolCall(providers.ToolCall{Name: "agent_web_fetch"}) {
|
|
t.Fatal("expected prefixed registered read-only tool to be parallel eligible")
|
|
}
|
|
}
|
|
|
|
// assertToolCallPayload verifies the event carries the expected tc identity
|
|
// and routing context from RunRequest.
|
|
func assertToolCallPayload(t *testing.T, ev AgentEvent, tc providers.ToolCall, req *RunRequest) {
|
|
t.Helper()
|
|
if ev.AgentID != "test-agent" {
|
|
t.Errorf("AgentID: got %q, want test-agent", ev.AgentID)
|
|
}
|
|
if ev.RunID != req.RunID {
|
|
t.Errorf("RunID: got %q, want %q", ev.RunID, req.RunID)
|
|
}
|
|
if ev.SessionKey != req.SessionKey {
|
|
t.Errorf("SessionKey: got %q, want %q", ev.SessionKey, req.SessionKey)
|
|
}
|
|
if ev.Channel != req.Channel {
|
|
t.Errorf("Channel: got %q, want %q", ev.Channel, req.Channel)
|
|
}
|
|
if ev.UserID != req.UserID {
|
|
t.Errorf("UserID: got %q, want %q", ev.UserID, req.UserID)
|
|
}
|
|
if ev.SenderID != req.SenderID {
|
|
t.Errorf("SenderID: got %q, want %q", ev.SenderID, req.SenderID)
|
|
}
|
|
payload, ok := ev.Payload.(map[string]any)
|
|
if !ok {
|
|
t.Fatalf("Payload is not map[string]any: %T", ev.Payload)
|
|
}
|
|
if payload["id"] != tc.ID {
|
|
t.Errorf("payload.id: got %v, want %q", payload["id"], tc.ID)
|
|
}
|
|
if payload["name"] != tc.Name {
|
|
t.Errorf("payload.name: got %v, want %q", payload["name"], tc.Name)
|
|
}
|
|
}
|