v1.0.1: Add builder pattern methods - WithSystemPrompt, WithModel, WithThinkingLevel, WithMaxTokens, WithTemperature, WithSkills, WithSkillSet, Prompt

Author: Patel230

agent.go

@@ -29,10 +29,17 @@ type Event struct {
 
 // Agent is the core reasoning loop.
 type Agent struct {
-	provider Provider
-	tools    map[string]Tool
-	logger   *slog.Logger
-	Events   chan Event
+	provider      Provider
+	tools         map[string]Tool
+	logger        *slog.Logger
+	Events        chan Event
+	SystemPrompt  string
+	Model         string
+	ThinkingLevel ThinkingLevel
+	MaxTokens     int
+	Temperature   float32
+	Skills        []Skill
+	Messages      []Message
 }
 
 // New creates a new Agent.
@@ -42,10 +49,14 @@ func New(p Provider, tools []Tool, logger *slog.Logger) *Agent {
 		toolMap[t.Name] = t
 	}
 	return &Agent{
-		provider: p,
-		tools:    toolMap,
-		logger:   logger,
-		Events:   make(chan Event, 64),
+		provider:      p,
+		tools:         toolMap,
+		logger:        logger,
+		Events:        make(chan Event, 64),
+		ThinkingLevel: ThinkingLevelOff,
+		MaxTokens:     4096,
+		Temperature:   0.7,
+		Messages:      []Message{},
 	}
 }
 
@@ -169,3 +180,135 @@ func ToolDescriptions(tools []Tool) string {
 	}
 	return sb.String()
 }
+
+func (a *Agent) WithSystemPrompt(prompt string) *Agent {
+	a.SystemPrompt = prompt
+	return a
+}
+
+func (a *Agent) WithModel(model string) *Agent {
+	a.Model = model
+	return a
+}
+
+func (a *Agent) WithThinkingLevel(level ThinkingLevel) *Agent {
+	a.ThinkingLevel = level
+	return a
+}
+
+func (a *Agent) WithMaxTokens(maxTokens int) *Agent {
+	a.MaxTokens = maxTokens
+	return a
+}
+
+func (a *Agent) WithTemperature(temp float32) *Agent {
+	a.Temperature = temp
+	return a
+}
+
+func (a *Agent) WithSkills(skills []Skill) *Agent {
+	a.Skills = skills
+	return a
+}
+
+func (a *Agent) WithSkillSet(skillSet *SkillSet) *Agent {
+	if skillSet != nil {
+		a.Skills = skillSet.Skills
+	}
+	return a
+}
+
+func (a *Agent) WithTools(tools []Tool) *Agent {
+	toolMap := make(map[string]Tool, len(tools))
+	for _, t := range tools {
+		toolMap[t.Name] = t
+	}
+	a.tools = toolMap
+	return a
+}
+
+func (a *Agent) GetTools() []Tool {
+	tools := make([]Tool, 0, len(a.tools))
+	for _, t := range a.tools {
+		tools = append(tools, t)
+	}
+	return tools
+}
+
+func (a *Agent) Prompt(ctx context.Context, text string) chan Event {
+	events := make(chan Event, 64)
+	go func() {
+		defer close(events)
+		events <- Event{Type: "message_start", Content: text}
+		output, err := a.Run(ctx, a.SystemPrompt, text)
+		if err != nil {
+			events <- Event{Type: "error", Content: err.Error()}
+		} else {
+			events <- Event{Type: "message_end", Content: output}
+		}
+	}()
+	return events
+}
+
+func (a *Agent) PromptMessages(ctx context.Context, messages []Message) chan Event {
+	events := make(chan Event, 64)
+	go func() {
+		defer close(events)
+		allTools := a.GetTools()
+		systemContent := a.SystemPrompt
+		if systemContent != "" {
+			systemContent += "\n\n"
+		}
+		systemContent += ToolDescriptions(allTools)
+
+		fullMessages := []Message{{Role: "system", Content: systemContent}}
+		fullMessages = append(fullMessages, messages...)
+
+		events <- Event{Type: "message_start", Content: ""}
+
+		for i := 0; i < 20; i++ {
+			events <- Event{Type: "turn_start", Content: fmt.Sprintf("turn %d", i+1)}
+
+			response, err := a.provider.Complete(ctx, fullMessages)
+			if err != nil {
+				events <- Event{Type: "error", Content: err.Error()}
+				break
+			}
+
+			events <- Event{Type: "content", Content: response}
+
+			fullMessages = append(fullMessages, Message{Role: "assistant", Content: response})
+
+			calls := ParseToolCalls(response)
+			if len(calls) == 0 {
+				events <- Event{Type: "message_end", Content: response}
+				break
+			}
+
+			var toolResults strings.Builder
+			for _, call := range calls {
+				tool, ok := a.tools[call.Tool]
+				if !ok {
+					result := fmt.Sprintf("unknown tool: %s", call.Tool)
+					toolResults.WriteString(fmt.Sprintf("Tool %s: %s\n", call.Tool, result))
+					events <- Event{Type: "tool_result", Content: result}
+					continue
+				}
+
+				events <- Event{Type: "tool_execution_start", Content: call.Tool}
+
+				result, err := tool.Execute(ctx, call.Args)
+				if err != nil {
+					result = fmt.Sprintf("ERROR: %s\nOutput: %s", err.Error(), result)
+				}
+
+				events <- Event{Type: "tool_execution_end", Content: result}
+				toolResults.WriteString(fmt.Sprintf("Tool %s result:\n%s\n\n", call.Tool, result))
+			}
+
+			fullMessages = append(fullMessages, Message{Role: "user", Content: toolResults.String()})
+			events <- Event{Type: "turn_end", Content: ""}
+		}
+	}()
+	return events
+}