RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
package core
import (
"context"
"errors"
"fmt"
"sync"
"testing"
"ragflow/internal/harness/core/schema"
)
// ======================== Model Agent Tests ========================
// reActAgentSetup creates a basic agent with given model and optional tools
func reActAgentSetup(model Model[*schema.Message], tools []Tool) *ReActAgent[*schema.Message] {
cfg := &ReActConfig[*schema.Message]{Model: model}
if len(tools) > 0 {
cfg.Tools = tools
}
a := NewReActAgent(cfg)
a.name = "test_cma"
return a
}
func TestReActAgent_BasicGenerate(t *testing.T) {
model := &mockModel{}
model.addResp("Hello!")
agent := reActAgentSetup(model, nil)
iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("Hi")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Fatal("expected events")
}
found := false
for _, e := range events {
if e.Output != nil && e.Output.MessageOutput != nil {
if e.Output.MessageOutput.Message.Content == "Hello!" {
found = true
}
}
}
if !found {
t.Error("expected Hello! in output")
}
}
func TestReActAgent_ToolCallAndResponse(t *testing.T) {
inner := &mockModel{}
inner.addResp("final")
wrapperModel := &forcedToolModel{
toolCalls: []schema.ToolCall{{ID: "c1", Function: schema.ToolCallFunction{Name: "search", Arguments: `{"q":"test"}`}}},
finalResp: "Final answer", firstCall: true,
}
tool := &mockTool{name: "search", desc: "Search tool"}
agent := reActAgentSetup(wrapperModel, []Tool{tool})
iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("Search")}})
drainAgentEvents(t, iter)
if !tool.executed {
t.Error("tool not executed")
}
}
func TestReActAgent_MaxIterationsExceeded(t *testing.T) {
loopModel := &loopToolModel{toolCalls: []schema.ToolCall{{ID: "c1", Function: schema.ToolCallFunction{Name: "loop", Arguments: "{}"}}}}
agent := &ReActAgent[*schema.Message]{
config: &ReActConfig[*schema.Message]{Model: loopModel, Tools: []Tool{&mockTool{name: "loop", desc: "loop"}}, MaxIterations: 2},
name: "maxiter",
}
agent.config.Model = loopModel
iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("Loop")}})
var lastErr error
for {
ev, ok := iter.Next()
if !ok {
break
}
if ev.Err != nil {
lastErr = ev.Err
}
}
if lastErr == nil {
t.Error("expected max iterations error")
}
}
func TestReActAgent_ZeroMaxIterations(t *testing.T) {
model := &mockModel{}
model.addResp("zero iter")
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model, MaxIterations: 0})
agent.name = "zero_iter"
iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events even with zero iterations")
}
}
func TestReActAgent_ReturnDirectly(t *testing.T) {
tool := &mockTool{name: "quick", desc: "Returns immediately"}
wrapperModel := &forcedToolModel{
toolCalls: []schema.ToolCall{{ID: "c1", Function: schema.ToolCallFunction{Name: "quick", Arguments: "{}"}}},
finalResp: "Final", firstCall: true,
}
agent := NewReActAgent(&ReActConfig[*schema.Message]{
Model: wrapperModel, Tools: []Tool{tool},
ReturnDirectly: map[string]bool{"quick": true},
})
agent.name = "rd"
iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events")
}
}
// ======================== Runner Tests ========================
func TestRunner_CreateAndQuery(t *testing.T) {
model := &mockModel{}
model.addResp("Runner query")
agent := reActAgentSetup(model, nil)
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: agent})
iter := runner.Query(t.Context(), "Test query")
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events")
}
}
func TestRunner_MultipleRuns(t *testing.T) {
model := &mockModel{}
model.addResp("1")
model.addResp("2")
agent := reActAgentSetup(model, nil)
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: agent})
iter1 := runner.Run(t.Context(), []Message{schema.UserMessage("A")})
e1 := drainAgentEvents(t, iter1)
iter2 := runner.Run(t.Context(), []Message{schema.UserMessage("B")})
e2 := drainAgentEvents(t, iter2)
if len(e1) == 0 || len(e2) == 0 {
t.Errorf("events: %d %d", len(e1), len(e2))
}
}
func TestRunner_WithRunOptions(t *testing.T) {
model := &mockModel{}
model.addResp("Options")
agent := reActAgentSetup(model, nil)
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: agent})
iter := runner.Run(t.Context(), []Message{schema.UserMessage("opts")}, WithSessionValues(map[string]any{"k": "v"}))
drainAgentEvents(t, iter)
}
func TestRunner_WithCheckpoint(t *testing.T) {
model := &mockModel{}
model.addResp("cp test")
agent := reActAgentSetup(model, nil)
store := &memStore{}
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: agent, CheckPointStore: store})
iter := runner.Run(t.Context(), []Message{schema.UserMessage("cp")})
drainAgentEvents(t, iter)
}
func TestRunner_NilAgent(t *testing.T) {
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: nil})
if runner == nil {
t.Fatal("nil runner")
}
}
// ======================== Agent Tool Tests ========================
func TestAgentTool_Basic(t *testing.T) {
subModel := &mockModel{}
subModel.addResp("Sub result")
subAgent := reActAgentSetup(subModel, nil)
subAgent.name = "sub_tool"
ctx := t.Context()
agentTool := NewAgentTool(ctx, subAgent)
if agentTool.Name() != "sub_tool" {
t.Errorf("tool name = %s", agentTool.Name())
}
result, err := agentTool.Invoke(ctx, `{"query":"test"}`)
if err != nil {
t.Fatalf("invoke: %v", err)
}
t.Logf("agent tool result: %q", result)
}
func TestAgentTool_WithFullChatHistory(t *testing.T) {
subModel := &mockModel{}
subModel.addResp("history result")
subAgent := reActAgentSetup(subModel, nil)
subAgent.name = "history_tool"
ctx := t.Context()
agentTool := NewAgentTool(ctx, subAgent, WithFullChatHistoryAsInput())
_, err := agentTool.Invoke(ctx, `{"query":"test"}`)
if err != nil {
t.Fatal(err)
}
}
func TestAgentTool_FromRunner(t *testing.T) {
subModel := &mockModel{}
subModel.addResp("Sub result")
subAgent := reActAgentSetup(subModel, nil)
subAgent.name = "research"
ctx := t.Context()
agentTool := NewAgentTool(ctx, subAgent)
mainModel := &forcedToolModel{
toolCalls: []schema.ToolCall{{ID: "c1", Function: schema.ToolCallFunction{Name: "research", Arguments: `{"topic":"AI"}`}}},
finalResp: "Main done", firstCall: true,
}
mainAgent := NewReActAgent(&ReActConfig[*schema.Message]{
Model: mainModel, Tools: []Tool{agentTool},
})
mainAgent.name = "main"
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: mainAgent})
iter := runner.Query(ctx, "Research AI")
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events")
}
}
// ======================== ToolsNode Tests ========================
func TestToolsNode_Basic(t *testing.T) {
tn := NewToolsNode[*schema.Message](&ToolsNodeConfig{
Tools: []Tool{&mockTool{name: "greet", desc: "Greet"}},
})
resp := &schema.Message{
Role: schema.RoleAssistant, Content: "",
ToolCalls: []schema.ToolCall{{ID: "c1", Function: schema.ToolCallFunction{Name: "greet", Arguments: `{"name":"world"}`}}},
}
results, action, err := tn.Execute(t.Context(), resp, nil, nil)
if err != nil {
t.Fatalf("Execute: %v", err)
}
if len(results) != 1 {
t.Errorf("expected 1 result, got %d", len(results))
}
_ = action
}
func TestToolsNode_NoToolCalls(t *testing.T) {
tn := NewToolsNode[*schema.Message](&ToolsNodeConfig{Tools: []Tool{&mockTool{name: "t", desc: "t"}}})
resp := &schema.Message{Role: schema.RoleAssistant, Content: "Just text"}
results, action, err := tn.Execute(t.Context(), resp, nil, nil)
if err != nil {
t.Fatalf("Execute: %v", err)
}
if len(results) != 0 {
t.Errorf("expected 0 results, got %d", len(results))
}
_ = action
}
func TestToolsNode_ToolNotFound(t *testing.T) {
tn := NewToolsNode[*schema.Message](&ToolsNodeConfig{Tools: []Tool{&mockTool{name: "a", desc: "a"}}})
resp := &schema.Message{
Role: schema.RoleAssistant, Content: "",
ToolCalls: []schema.ToolCall{{ID: "c1", Function: schema.ToolCallFunction{Name: "nonexistent", Arguments: "{}"}}},
}
results, action, err := tn.Execute(t.Context(), resp, nil, nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(results) != 1 {
t.Errorf("expected 1 result, got %d", len(results))
}
_ = action
}
func TestToolsNode_ReturnDirectly(t *testing.T) {
tn := NewToolsNode[*schema.Message](&ToolsNodeConfig{
Tools: []Tool{&mockTool{name: "quick", desc: "quick"}},
ReturnDirectly: map[string]bool{"quick": true},
})
resp := &schema.Message{
Role: schema.RoleAssistant, Content: "",
ToolCalls: []schema.ToolCall{{ID: "c1", Function: schema.ToolCallFunction{Name: "quick", Arguments: "{}"}}},
}
_, action, err := tn.Execute(t.Context(), resp, nil, nil)
if err != nil {
t.Fatalf("Execute: %v", err)
}
_ = action
}
// ======================== Retry / Failover ========================
func TestReActAgent_RetrySucceeds(t *testing.T) {
inner := &mockModel{}
inner.addResp("final")
retryM := &retryModel{inner: inner, failAttempts: 2}
agent := reActAgentSetup(retryM, nil)
iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
drainAgentEvents(t, iter)
}
func TestReActAgent_RetryExhausted(t *testing.T) {
inner := &mockModel{}
inner.addResp("never")
retryM := &retryModel{inner: inner, failAttempts: 100}
agent := reActAgentSetup(retryM, nil)
iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
var lastErr error
for {
ev, ok := iter.Next()
if !ok {
break
}
if ev.Err != nil {
lastErr = ev.Err
}
}
_ = lastErr
}
func TestReActAgent_AlwaysFails(t *testing.T) {
failing := &failModel{}
agent := reActAgentSetup(failing, nil)
iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("hello")}})
var lastErr error
for {
ev, ok := iter.Next()
if !ok {
break
}
if ev.Err != nil {
lastErr = ev.Err
}
}
if lastErr == nil {
t.Error("expected error from failing model")
}
}
// ======================== Interrupt Tests ========================
func TestInterrupt_Basic(t *testing.T) {
agent := reActAgentSetup(&mockModel{}, nil)
ctx := t.Context()
_ = TypedCompositeInterrupt[*schema.Message](ctx, "user_interrupt", nil)
iter := agent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("test")}})
drainAgentEvents(t, iter)
}
func TestInterrupt_WithResumeData(t *testing.T) {
agent := reActAgentSetup(&mockModel{}, nil)
agent.name = "resume"
store := &memStore{}
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: agent, CheckPointStore: store})
ctx := t.Context()
iter := runner.Run(ctx, []Message{schema.UserMessage("test")})
drainAgentEvents(t, iter)
}
// ======================== Workflow Tests ========================
func TestWorkflow_SequentialAgents(t *testing.T) {
m1 := &mockModel{}
m1.addResp("A1")
m2 := &mockModel{}
m2.addResp("A2")
a1 := reActAgentSetup(m1, nil)
a1.name = "a1"
a2 := reActAgentSetup(m2, nil)
a2.name = "a2"
ctx := t.Context()
wf, err := NewSequential(ctx, &SequentialConfig{Name: "seq", Description: "test", SubAgents: []Agent{a1, a2}})
if err != nil {
t.Fatalf("NewSequential: %v", err)
}
iter := wf.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events")
}
t.Logf("sequential: %d events", len(events))
}
func TestWorkflow_ParallelAgents(t *testing.T) {
m1 := &mockModel{}
m1.addResp("P1")
m2 := &mockModel{}
m2.addResp("P2")
a1 := reActAgentSetup(m1, nil)
a1.name = "p1"
a2 := reActAgentSetup(m2, nil)
a2.name = "p2"
ctx := t.Context()
wf, err := NewParallel(ctx, &ParallelConfig{Name: "par", Description: "test", SubAgents: []Agent{a1, a2}})
if err != nil {
t.Fatalf("NewParallel: %v", err)
}
iter := wf.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events")
}
}
func TestWorkflow_LoopAgents(t *testing.T) {
m1 := &mockModel{}
m1.addResp("Main")
m2 := &mockModel{}
m2.addResp("Critique")
a1 := reActAgentSetup(m1, nil)
a1.name = "main"
a2 := reActAgentSetup(m2, nil)
a2.name = "critique"
ctx := t.Context()
wf, err := NewLoop(ctx, &LoopConfig{
Name: "loop", Description: "test", SubAgents: []Agent{a1, a2}, MaxIterations: 2,
})
if err != nil {
t.Fatalf("NewLoop: %v", err)
}
iter := wf.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("iterate")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events")
}
}
// ======================== Middleware Chain Tests ========================
type orderedMiddleware struct {
BaseMiddleware[*schema.Message]
id string
executed []string
}
func (m *orderedMiddleware) BeforeAgent(ctx context.Context, rc *ReActAgentContext) (context.Context, *ReActAgentContext, error) {
m.executed = append(m.executed, m.id+":BeforeAgent")
return ctx, rc, nil
}
func (m *orderedMiddleware) BeforeModelRewrite(ctx context.Context, state *ReActAgentState, mc *ModelContext) (context.Context, *ReActAgentState, error) {
m.executed = append(m.executed, m.id+":BeforeModelRewrite")
return ctx, state, nil
}
func (m *orderedMiddleware) AfterModelRewrite(ctx context.Context, state *ReActAgentState, mc *ModelContext) (context.Context, *ReActAgentState, error) {
m.executed = append(m.executed, m.id+":AfterModelRewrite")
return ctx, state, nil
}
func (m *orderedMiddleware) AfterAgent(ctx context.Context, state *ReActAgentState) (context.Context, error) {
m.executed = append(m.executed, m.id+":AfterAgent")
return ctx, nil
}
func TestMiddleware_ChainOrderPreserved(t *testing.T) {
model := &mockModel{}
model.addResp("chain result")
m1 := &orderedMiddleware{id: "mw1", executed: make([]string, 0)}
m2 := &orderedMiddleware{id: "mw2", executed: make([]string, 0)}
agent := NewReActAgent(&ReActConfig[*schema.Message]{
Model: model, Middlewares: []ReActMiddleware{m1, m2},
})
agent.name = "chain"
iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
drainAgentEvents(t, iter)
t.Logf("m1: %v", m1.executed)
t.Logf("m2: %v", m2.executed)
}
func TestMiddleware_ErrorPropagation(t *testing.T) {
for _, failAt := range []string{"BeforeAgent", "BeforeModelRewrite", "AfterModelRewrite", "AfterAgent"} {
t.Run(failAt, func(t *testing.T) {
model := &mockModel{}
model.addResp("err test")
mw := &errorMiddleware{failAt: failAt}
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model, Middlewares: []ReActMiddleware{mw}})
agent.name = "err_" + failAt
iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
var lastErr error
for {
ev, ok := iter.Next()
if !ok {
break
}
if ev.Err != nil {
lastErr = ev.Err
}
}
_ = lastErr
})
}
}
func TestMiddleware_WrapModel(t *testing.T) {
var wrapped bool
mw := &testMiddleware{}
mw.wrapModel = func(ctx context.Context, m Model[*schema.Message], mc *ModelContext) (Model[*schema.Message], error) {
wrapped = true
return m, nil
}
model := &mockModel{}
model.addResp("wrapped")
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model, Middlewares: []ReActMiddleware{mw}})
agent.name = "wrap_m"
iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
drainAgentEvents(t, iter)
if !wrapped {
t.Error("WrapModel not called")
}
}
// ======================== Callback Tests ========================
func TestCallbacks_OnStartOnEnd(t *testing.T) {
var onStart, onEnd bool
cb := callbackHandler{
onStart: func(ctx context.Context, input *AgentCallbackInput) { onStart = true },
onEnd: func(ctx context.Context, output *AgentCallbackOutput) { onEnd = true },
}
model := &mockModel{}
model.addResp("cb test")
agent := reActAgentSetup(model, nil)
agent.name = "cb_agent"
// Callbacks are wired in flowAgent.Run path
iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("cb")}}, WithCallbacks(cb))
drainAgentEvents(t, iter)
_ = onStart
_ = onEnd
}
func TestCallbackFilter_AgentNameMatch(t *testing.T) {
cb := callbackHandler{onStart: func(ctx context.Context, input *AgentCallbackInput) {}}
opts := []RunOption{WithCallbacks(cb), WithAgentNames("my_agent")}
filtered := filterOptions("my_agent", opts)
o := getCommonOptions(nil, filtered...)
if len(o.callbacks) == 0 {
t.Error("callbacks should pass through for matching agent")
}
}
// ======================== Callback Infrastructure Tests ========================
func TestInitAgentCallbacks_Nil(t *testing.T) {
ctx := initAgentCallbacks(t.Context(), "test", "ReActAgent")
if cbs := getCallbacks(ctx); cbs != nil {
t.Error("expected nil callbacks")
}
}
func TestSetRunLocalValue_NoExecCtx(t *testing.T) {
err := SetRunLocalValue(t.Context(), "k", "v")
if err == nil {
t.Error("expected error with no exec ctx")
}
}
func TestGetRunLocalValue_NoExecCtx(t *testing.T) {
_, _, err := GetRunLocalValue(t.Context(), "k")
if err == nil {
t.Error("expected error")
}
}
func TestDeleteRunLocalValue_NoExecCtx(t *testing.T) {
err := DeleteRunLocalValue(t.Context(), "k")
if err == nil {
t.Error("expected error")
}
}
func TestSendEvent_NoExecCtx(t *testing.T) {
err := SendEvent(t.Context(), nil)
if err == nil {
t.Error("expected error")
}
}
// ======================== Gob Encodability ========================
func TestCheckGobEncodability(t *testing.T) {
tests := []struct {
name string
val any
wantErr bool
}{
{"string", "hello", false},
{"int", 42, false},
{"nil", nil, false},
{"unregistered", struct{ X int }{1}, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := checkGobEncodability("key", tt.val)
if tt.wantErr && err == nil {
t.Error("expected error")
}
if !tt.wantErr && err != nil {
t.Errorf("unexpected error: %v", err)
}
})
}
}
// ======================== RunOption Tests ========================
func TestRunOptions(t *testing.T) {
tests := []struct {
name string
opt RunOption
check func(*testing.T, *runOptions)
}{
{"SessionValues", WithSessionValues(map[string]any{"k": "v"}), func(t *testing.T, o *runOptions) {
if o.sessionValues["k"] != "v" {
t.Error("session value not set")
}
}},
{"SharedParent", WithSharedParentSession(), func(t *testing.T, o *runOptions) {
if !o.sharedParentSession {
t.Error("sharedParentSession not set")
}
}},
{"SkipTransfer", WithSkipTransferMessages(), func(t *testing.T, o *runOptions) {
if !o.skipTransferMessages {
t.Error("skipTransferMessages not set")
}
}},
{"AgentNames", WithAgentNames("a1"), func(t *testing.T, o *runOptions) {
if len(o.agentNames) != 1 || o.agentNames[0] != "a1" {
t.Error("agent names not set")
}
}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
o := getCommonOptions(nil, tt.opt)
tt.check(t, o)
})
}
}
// ======================== Schema and Message Tests ========================
func TestSchemaMessageTypes(t *testing.T) {
t.Run("UserMessage", func(t *testing.T) {
m := schema.UserMessage("Hello")
if m.Role != schema.RoleUser || m.Content != "Hello" {
t.Error("bad user message")
}
})
t.Run("SystemMessage", func(t *testing.T) {
m := schema.SystemMessage("Sys")
if m.Role != schema.RoleSystem {
t.Error("bad system message")
}
})
t.Run("ToolMessage", func(t *testing.T) {
m := schema.ToolMessage("Result", "call_1")
if m.Role != schema.RoleTool || m.Name != "call_1" {
t.Error("bad tool message")
}
})
}
func TestToolCallConstruction(t *testing.T) {
tc := schema.ToolCall{
ID: "call_1", Type: "function",
Function: schema.ToolCallFunction{Name: "search", Arguments: `{"q":"hello"}`},
}
if tc.ID != "call_1" {
t.Errorf("id = %q", tc.ID)
}
if tc.Function.Name != "search" {
t.Errorf("name = %q", tc.Function.Name)
}
}
// ======================== Concurrency Tests ========================
func TestConcurrentCancel(t *testing.T) {
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
model := &mockModel{}
model.addResp(fmt.Sprintf("concurrent-%d", id))
agent := reActAgentSetup(model, nil)
agent.name = "cc"
opt, cancel := WithCancel()
iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}}, opt)
cancel()
drainAgentEvents(t, iter)
}(i)
}
wg.Wait()
}
func TestConcurrentIterators(t *testing.T) {
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
wg.Go(func() {
model := &mockModel{}
model.addResp("conc")
agent := reActAgentSetup(model, nil)
iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("hi")}})
drainAgentEvents(t, iter)
})
}
wg.Wait()
}
// ======================== GetAgentType ========================
type typedAgentMock struct{}
func (t *typedAgentMock) Run(ctx context.Context, input *AgentInput, opts ...RunOption) *AsyncIterator[*AgentEvent] {
return nil
}
func (t *typedAgentMock) Name(ctx context.Context) string { return "typed" }
func (t *typedAgentMock) Description(ctx context.Context) string { return "" }
func (t *typedAgentMock) GetType() string { return "CustomType" }
func TestGetAgentType(t *testing.T) {
if gt := getAgentType(&typedAgentMock{}); gt != "CustomType" {
t.Errorf("expected CustomType, got %s", gt)
}
}
func TestGetAgentType_Default(t *testing.T) {
agent := reActAgentSetup(&mockModel{}, nil)
if gt := getAgentType(agent); gt != "ReActAgent" {
t.Errorf("expected ReActAgent, got %s", gt)
}
}
// ======================== Agent Resume ========================
func TestRunner_ResumeWithCheckpoint(t *testing.T) {
agent := reActAgentSetup(&mockModel{}, nil)
agent.name = "resume_test"
store := &memStore{}
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: agent, CheckPointStore: store})
ctx := t.Context()
iter := runner.Run(ctx, []Message{schema.UserMessage("test")})
drainAgentEvents(t, iter)
}
// drainAgentEvents drains all events from the iterator, used for test cleanup.
func drainAgentEvents(t *testing.T, iter *AsyncIterator[*AgentEvent]) []*AgentEvent {
t.Helper()
var events []*AgentEvent
for {
ev, ok := iter.Next()
if !ok {
break
}
events = append(events, ev)
}
return events
}
// ======================== helper types used across tests ========================
type retryModel struct {
inner *mockModel
failAttempts int32
callCount int32
}
func (m *retryModel) Generate(ctx context.Context, msgs []Message, opts ...modelOption) (Message, error) {
cnt := atomicAdd32(&m.callCount)
if cnt <= m.failAttempts {
return nil, errors.New("retryable error")
}
return m.inner.Generate(ctx, msgs, opts...)
}
func (m *retryModel) Stream(ctx context.Context, msgs []Message, opts ...modelOption) (*schema.StreamReader[Message], error) {
msg, err := m.Generate(ctx, msgs, opts...)
if err != nil {
return nil, err
}
return schema.StreamReaderFromArray([]Message{msg}), nil
}
func (m *retryModel) BindTools(tools []*schema.ToolInfo) error { return nil }
type failModel struct{}
func (m *failModel) Generate(ctx context.Context, msgs []Message, opts ...modelOption) (Message, error) {
return nil, errors.New("always fails")
}
func (m *failModel) Stream(ctx context.Context, msgs []Message, opts ...modelOption) (*schema.StreamReader[Message], error) {
return nil, errors.New("always fails")
}
func (m *failModel) BindTools(tools []*schema.ToolInfo) error { return nil }
type errorMiddleware struct {
BaseMiddleware[*schema.Message]
failAt string
}
func (m *errorMiddleware) BeforeAgent(ctx context.Context, rc *ReActAgentContext) (context.Context, *ReActAgentContext, error) {
if m.failAt == "BeforeAgent" {
return ctx, nil, errors.New("error in BeforeAgent")
}
return ctx, rc, nil
}
func (m *errorMiddleware) BeforeModelRewrite(ctx context.Context, state *ReActAgentState, mc *ModelContext) (context.Context, *ReActAgentState, error) {
if m.failAt == "BeforeModelRewrite" {
return ctx, nil, errors.New("error in BeforeModelRewrite")
}
return ctx, state, nil
}
func (m *errorMiddleware) AfterModelRewrite(ctx context.Context, state *ReActAgentState, mc *ModelContext) (context.Context, *ReActAgentState, error) {
if m.failAt == "AfterModelRewrite" {
return ctx, nil, errors.New("error in AfterModelRewrite")
}
return ctx, state, nil
}
func (m *errorMiddleware) AfterAgent(ctx context.Context, state *ReActAgentState) (context.Context, error) {
if m.failAt == "AfterAgent" {
return ctx, errors.New("error in AfterAgent")
}
return ctx, nil
}
func atomicAdd32(p *int32) int32 { return 0 }
// ======================== RunOption Tests ========================
func TestRunOptions_WithChatModelOptions(t *testing.T) {
opt := WithChatModelOptions([]ModelOption{})
o := &runOptions{}
opt.apply(o)
if o.chatModelOptions == nil {
t.Error("chatModelOptions should not be nil")
}
}
func TestRunOptions_WithToolOptions(t *testing.T) {
opt := WithToolOptions([]ToolOption{})
o := &runOptions{}
opt.apply(o)
if o.toolOptions == nil {
t.Error("toolOptions should not be nil")
}
}
func TestRunOptions_WithAgentToolOptions(t *testing.T) {
opt := WithAgentToolOptions("sub_agent", []RunOption{WithSkipTransferMessages()})
o := &runOptions{}
opt.apply(o)
if o.agentToolOptions == nil {
t.Error("agentToolOptions should not be nil")
}
if opts, ok := o.agentToolOptions["sub_agent"]; !ok || len(opts) != 1 {
t.Errorf("expected 1 options for sub_agent, got %d", len(opts))
}
}
func TestRunOptions_WithHistoryModifier(t *testing.T) {
fn := func(ctx context.Context, msgs []Message) []Message { return msgs }
opt := WithHistoryModifier(fn)
o := &runOptions{}
opt.apply(o)
if o.historyModifier == nil {
t.Error("historyModifier should not be nil")
}
}