v1.0.3: Add rich Event struct, Mock provider, OpenAI Responses provider

Author: Patel230

agent.go

@@ -23,8 +23,14 @@ type Tool struct {
 
 // Event represents a step in the agent's reasoning.
 type Event struct {
-	Type    string
-	Content string
+	Type       string
+	Content    string
+	ToolCallID string
+	ToolName   string
+	Args       map[string]interface{}
+	Result     string
+	IsError    bool
+	Thinking   string
 }
 
 // Agent is the core reasoning loop.
@@ -75,14 +81,15 @@ func (a *Agent) Run(ctx context.Context, systemPrompt, userMessage string) (stri
 	const maxIterations = 20
 	for i := 0; i < maxIterations; i++ {
 		a.logger.Info("agent iteration", "step", i+1)
+		a.emit(Event{Type: string(EventTurnStart), Content: fmt.Sprintf("turn %d", i+1)})
 
 		response, err := a.provider.Complete(ctx, messages)
 		if err != nil {
-			a.emit(Event{Type: "error", Content: err.Error()})
+			a.emit(Event{Type: string(EventError), Content: err.Error(), IsError: true})
 			return "", fmt.Errorf("provider error at step %d: %w", i+1, err)
 		}
 
-		a.emit(Event{Type: "thought", Content: response})
+		a.emit(Event{Type: string(EventMessageUpdate), Content: response})
 
 		messages = append(messages, Message{
 			Role:    "assistant",
@@ -91,7 +98,8 @@ func (a *Agent) Run(ctx context.Context, systemPrompt, userMessage string) (stri
 
 		calls := ParseToolCalls(response)
 		if len(calls) == 0 {
-			a.emit(Event{Type: "done", Content: response})
+			a.emit(Event{Type: string(EventMessageEnd), Content: response})
+			a.emit(Event{Type: string(EventTurnEnd), Content: ""})
 			return response, nil
 		}
 
@@ -101,26 +109,43 @@ func (a *Agent) Run(ctx context.Context, systemPrompt, userMessage string) (stri
 			if !ok {
 				result := fmt.Sprintf("unknown tool: %s", call.Tool)
 				toolResults.WriteString(fmt.Sprintf("Tool %s: %s\n", call.Tool, result))
-				a.emit(Event{Type: "tool_result", Content: result})
+				a.emit(Event{Type: string(EventToolExecutionEnd), ToolName: call.Tool, Result: result, IsError: true})
 				continue
 			}
 
-			a.emit(Event{Type: "tool_call", Content: fmt.Sprintf("%s(%v)", call.Tool, call.Args)})
+			argsMap := make(map[string]interface{})
+			for k, v := range call.Args {
+				argsMap[k] = v
+			}
+			a.emit(Event{
+				Type:       string(EventToolExecutionStart),
+				ToolName:   call.Tool,
+				ToolCallID: call.Tool + "-" + fmt.Sprintf("%d", i),
+				Args:       argsMap,
+			})
 			a.logger.Info("executing tool", "tool", call.Tool, "args", call.Args)
 
 			result, err := tool.Execute(ctx, call.Args)
+			isError := false
 			if err != nil {
 				result = fmt.Sprintf("ERROR: %s\nOutput: %s", err.Error(), result)
+				isError = true
 			}
 
-			a.emit(Event{Type: "tool_result", Content: result})
+			a.emit(Event{
+				Type:     string(EventToolExecutionEnd),
+				ToolName: call.Tool,
+				Result:   result,
+				IsError:  isError,
+			})
 			toolResults.WriteString(fmt.Sprintf("Tool %s result:\n%s\n\n", call.Tool, result))
 		}
 
 		messages = append(messages, Message{
 			Role:    "user",
 			Content: toolResults.String(),
 		})
+		a.emit(Event{Type: string(EventTurnEnd), Content: ""})
 	}
 
 	return "", fmt.Errorf("agent exceeded max iterations (%d)", maxIterations)

mock.go

@@ -0,0 +1,155 @@
+package iteragent
+
+import (
+	"context"
+	"fmt"
+	"strings"
+)
+
+type MockProvider struct {
+	model         string
+	response      string
+	toolCalls     []ToolCall
+	toolCallIndex int
+	error         error
+}
+
+func NewMock(response string) *MockProvider {
+	return &MockProvider{
+		model:    "mock",
+		response: response,
+	}
+}
+
+func NewMockWithTools(response string, toolCalls []ToolCall) *MockProvider {
+	return &MockProvider{
+		model:     "mock",
+		response:  response,
+		toolCalls: toolCalls,
+	}
+}
+
+func NewMockWithError(err error) *MockProvider {
+	return &MockProvider{
+		model: "mock",
+		error: err,
+	}
+}
+
+func (p *MockProvider) Name() string {
+	return fmt.Sprintf("mock(%s)", p.model)
+}
+
+func (p *MockProvider) Complete(ctx context.Context, messages []Message) (string, error) {
+	if p.error != nil {
+		return "", p.error
+	}
+
+	if p.toolCallIndex < len(p.toolCalls) {
+		call := p.toolCalls[p.toolCallIndex]
+		p.toolCallIndex++
+		return fmt.Sprintf("```tool\n%s\n```", mustJson(call)), nil
+	}
+
+	return p.response, nil
+}
+
+func (p *MockProvider) Stream(ctx context.Context, config StreamConfig, messages []Message, onEvent func(StreamEvent)) (Message, error) {
+	if p.error != nil {
+		return Message{}, p.error
+	}
+
+	for _, char := range strings.Split(p.response, "") {
+		select {
+		case <-ctx.Done():
+			return Message{}, ctx.Err()
+		default:
+		}
+		onEvent(StreamEvent{
+			Type:    StreamEventContent,
+			Content: char,
+		})
+	}
+
+	return Message{
+		Role:    "assistant",
+		Content: p.response,
+	}, nil
+}
+
+func mustJson(v interface{}) string {
+	switch v := v.(type) {
+	case string:
+		return v
+	default:
+		return fmt.Sprintf("%+v", v)
+	}
+}
+
+type MockProviderBuilder struct {
+	mock *MockProvider
+}
+
+func Mock() *MockProviderBuilder {
+	return &MockProviderBuilder{
+		mock: &MockProvider{
+			model: "mock",
+		},
+	}
+}
+
+func (b *MockProviderBuilder) Text(text string) *MockProviderBuilder {
+	b.mock.response = text
+	return b
+}
+
+func (b *MockProviderBuilder) Model(model string) *MockProviderBuilder {
+	b.mock.model = model
+	return b
+}
+
+func (b *MockProviderBuilder) WithTools(toolCalls ...ToolCall) *MockProviderBuilder {
+	b.mock.toolCalls = toolCalls
+	return b
+}
+
+func (b *MockProviderBuilder) WithError(err error) *MockProviderBuilder {
+	b.mock.error = err
+	return b
+}
+
+func (b *MockProviderBuilder) Build() Provider {
+	return b.mock
+}
+
+type MockStreamProvider struct {
+	events []StreamEvent
+	index  int
+}
+
+func NewMockStreamProvider(events []StreamEvent) *MockStreamProvider {
+	return &MockStreamProvider{
+		events: events,
+	}
+}
+
+func (p *MockStreamProvider) Stream(ctx context.Context, config StreamConfig, messages []Message, onEvent func(StreamEvent)) (Message, error) {
+	var content strings.Builder
+
+	for _, event := range p.events {
+		select {
+		case <-ctx.Done():
+			return Message{}, ctx.Err()
+		default:
+		}
+		onEvent(event)
+		if event.Content != "" {
+			content.WriteString(event.Content)
+		}
+	}
+
+	return Message{
+		Role:    "assistant",
+		Content: content.String(),
+	}, nil
+}