chore: add a way to track reasoning only

Signed-off-by: Ettore Di Giacinto <[email protected]>

Author: mudler

options.go

@@ -10,30 +10,30 @@ import (
 // Options contains all configuration options for the Cogito agent
 // It allows customization of behavior, tools, prompts, and execution parameters
 type Options struct {
-	prompts                prompt.PromptMap
-	maxIterations          int
-	tools                  Tools
-	deepContext            bool
-	toolReasoner           bool
-	toolReEvaluator        bool
-	autoPlan               bool
-	planReEvaluator        bool
-	statusCallback         func(string)
-	gaps                   []string
-	context                context.Context
-	infiniteExecution      bool
-	maxAttempts            int
-	feedbackCallback       func() *Fragment
-	toolCallCallback       func(*ToolChoice) bool
-	toolCallResultCallback func(ToolStatus)
-	strictGuidelines       bool
-	mcpSessions            []*mcp.ClientSession
-	guidelines             Guidelines
-	mcpPrompts             bool
-	mcpArgs                map[string]string
-	maxRetries             int
-	loopDetectionSteps     int
-	forceReasoning         bool
+	prompts                           prompt.PromptMap
+	maxIterations                     int
+	tools                             Tools
+	deepContext                       bool
+	toolReasoner                      bool
+	toolReEvaluator                   bool
+	autoPlan                          bool
+	planReEvaluator                   bool
+	statusCallback, reasoningCallback func(string)
+	gaps                              []string
+	context                           context.Context
+	infiniteExecution                 bool
+	maxAttempts                       int
+	feedbackCallback                  func() *Fragment
+	toolCallCallback                  func(*ToolChoice) bool
+	toolCallResultCallback            func(ToolStatus)
+	strictGuidelines                  bool
+	mcpSessions                       []*mcp.ClientSession
+	guidelines                        Guidelines
+	mcpPrompts                        bool
+	mcpArgs                           map[string]string
+	maxRetries                        int
+	loopDetectionSteps                int
+	forceReasoning                    bool
 }
 
 type Option func(*Options)
@@ -221,3 +221,10 @@ func WithForceReasoning() func(o *Options) {
 		o.forceReasoning = true
 	}
 }
+
+// WithReasoningCallback sets a callback function to receive reasoning updates during execution
+func WithReasoningCallback(fn func(string)) func(o *Options) {
+	return func(o *Options) {
+		o.reasoningCallback = fn
+	}
+}

tools.go

@@ -632,13 +632,18 @@ func toolSelection(llm LLM, f Fragment, tools Tools, guidelines Guidelines, tool
 		// No tool was selected, reasoning contains the response
 		xlog.Debug("[toolSelection] No tool selected", "reasoning", reasoning)
 		o.statusCallback(reasoning)
+		o.reasoningCallback("No tool selected")
 		// TODO: reasoning in this case would be the LLM's response to the user, not the tool selection
 		// But, ExecuteTools doesn't return ther response, but just executes the tools and returns the result of the tools.
 		// In this way, we are wasting computation as the user will ask again the LLM for computing the response
 		// (again, while we could have used the reasoning as it is actually a response if no tools were selected)
 		return f, nil, true, nil
 	}
 
+	if reasoning != "" {
+		o.reasoningCallback(reasoning)
+	}
+
 	xlog.Debug("[toolSelection] Tool selected", "tool", selectedTool.Name, "reasoning", reasoning)
 	o.statusCallback(fmt.Sprintf("Selected tool: %s", selectedTool.Name))
 
@@ -701,22 +706,21 @@ func ExecuteTools(llm LLM, f Fragment, opts ...Option) (Fragment, error) {
 	// If the tool reasoner is enabled, we first try to figure out if we need to call a tool or not
 	// We ask to the LLM, and then we extract a boolean from the answer
 	if o.toolReasoner {
-
 		// ToolReasoner will call guidelines and tools for the initial fragment
 		toolReason, err := ToolReasoner(llm, f, opts...)
 		if err != nil {
 			return f, fmt.Errorf("failed to extract boolean: %w", err)
 		}
 
-		o.statusCallback(f.LastMessage().Content)
-
 		boolean, err := ExtractBoolean(llm, toolReason, opts...)
 		if err != nil {
 			return f, fmt.Errorf("failed extracting boolean: %w", err)
 		}
 		xlog.Debug("Tool reasoning", "wants_tool", boolean.Boolean)
 		if !boolean.Boolean {
 			xlog.Debug("LLM decided to not use any tool")
+			o.statusCallback("Ended reasoning without using any tool")
+			o.reasoningCallback("Ended reasoning without using any tool")
 			return f, ErrNoToolSelected
 		}
 	}