Allow read-only tools during fan-out and preserve tool history in conversation

Two fixes for "providers not receiving tool execution results":

1. Fan-out now supports read-only tools (file_read). Providers can inspect
   the codebase during their initial response instead of giving generic
   advice. Write/exec tools remain synthesis-only. Fan-out tool calls are
   executed inline with up to 3 re-query rounds per provider.

2. Tool calls and results are now preserved as structured messages in the
   conversation state (assistant+ToolCalls → RoleTool results → follow-up).
   Previously flattened to a text blob, losing tool context for subsequent
   turns. ToolLoop.RunWithMessages returns the appended messages for the
   caller to store in conv.

Author: izzoa

CHANGELOG.md

@@ -6,6 +6,14 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/), and this
 
 ## [Unreleased]
 
+## [1.13.0] - 2026-03-23
+
+### Added
+- **Read-only tools during fan-out**: Providers can now use `file_read` during fan-out to inspect the codebase before responding, instead of giving generic advice. Write and exec tools remain synthesis-only.
+
+### Fixed
+- **Tool results lost from conversation history**: Tool calls and results are now preserved as structured messages in the conversation state (assistant+tool_calls → tool results → follow-up). Previously they were flattened to a single text blob, so providers lost tool context on subsequent turns.
+
 ## [1.12.1] - 2026-03-22
 
 ### Fixed

README.md

@@ -29,7 +29,7 @@ Every AI model has blind spots. Claude might excel at architecture, GPT at debug
 
 ### Multi-Provider Consensus
 
-Query every configured LLM simultaneously. Responses fan out in parallel (latency = slowest provider, not sum of all), and your designated **primary** model synthesizes them into a single answer — identifying areas of agreement, unique insights, and errors.
+Query every configured LLM simultaneously. Responses fan out in parallel (latency = slowest provider, not sum of all), and your designated **primary** model synthesizes them into a single answer — identifying areas of agreement, unique insights, and errors. Providers can read files during fan-out to give codebase-aware answers.
 
 ### Supported Providers
 

cmd/polycode/app.go

@@ -740,6 +740,20 @@ func startTUI(cfg *config.Config) error {
 				synthesisMode,
 			)
 
+			// Allow read-only tools (file_read) during fan-out so providers
+			// can inspect the codebase to give informed answers.
+			fanOutExecutor := action.NewExecutor(nil, 30*time.Second)
+			queryPipeline.SetFanOutTools(
+				action.ReadOnlyTools(),
+				func(call provider.ToolCall) (string, error) {
+					result := fanOutExecutor.Execute(call)
+					if result.Error != nil {
+						return result.Output, result.Error
+					}
+					return result.Output, nil
+				},
+			)
+
 			// Accumulate fan-out text per provider from the live (untruncated) stream.
 			// The chunk callback fires from concurrent goroutines, so this needs a mutex.
 			var fanoutMu sync.Mutex
@@ -960,8 +974,11 @@ func startTUI(cfg *config.Config) error {
 			}
 
 			// NOTE: Don't append fullResponse to conv yet — if tool execution
-			// follows, we want to combine initial text + tool output into one
-			// assistant message so future turns have full context.
+			// follows, we want to preserve the structured tool call/result
+			// messages in the conversation state for future turns.
+			var toolResponse string
+			var toolLoopMsgs []provider.Message
+			var consensusText string // consensus text before tool output (for structured conv state)
 
 			// Execute tool calls if the consensus response included them
 			if len(pendingToolCalls) > 0 {
@@ -1068,13 +1085,14 @@ func startTUI(cfg *config.Config) error {
 				toolOut := make(chan provider.StreamChunk, 16)
 				go func() {
 					defer toolCancel()
-					if err := toolLoop.Run(toolCtx, toolMsgs, pendingToolCalls, opts, toolOut); err != nil {
+					loopMsgs, err := toolLoop.RunWithMessages(toolCtx, toolMsgs, pendingToolCalls, opts, toolOut)
+					toolLoopMsgs = loopMsgs // writes to outer var; safe because consumer drains toolOut first
+					if err != nil {
 						toolOut <- provider.StreamChunk{Error: err}
 					}
 					close(toolOut)
 				}()
 
-				var toolResponse string
 				var toolLoopOK bool
 				var wroteFiles bool
 				for chunk := range toolOut {
@@ -1111,7 +1129,10 @@ func startTUI(cfg *config.Config) error {
 				}
 				toolCancel()
 
-				// Combine initial consensus text + tool follow-up
+				// Save consensus-only text before combining (needed for structured conv state).
+				consensusText = fullResponse
+
+				// Combine initial consensus text + tool follow-up for display/history.
 				if toolResponse != "" {
 					fullResponse += "\n" + toolResponse
 				}
@@ -1188,9 +1209,20 @@ func startTUI(cfg *config.Config) error {
 				program.Send(tui.ConsensusChunkMsg{Done: true})
 			}
 
-			// Append the complete assistant response (initial consensus + tool output)
-			// as a single message so future turns have full context
-			if fullResponse != "" {
+			// Append conversation messages so future turns have full context.
+			// When tool calls occurred, preserve the structured message sequence
+			// (assistant+tool_calls → tool results → follow-up assistant) so
+			// providers with native tool support get proper conversation history.
+			if len(pendingToolCalls) > 0 && len(toolLoopMsgs) > 0 {
+				// Initial assistant message with tool calls
+				conv.append(provider.Message{
+					Role:      provider.RoleAssistant,
+					Content:   consensusText,
+					ToolCalls: pendingToolCalls,
+				})
+				// Tool results and follow-up messages from the tool loop
+				conv.append(toolLoopMsgs...)
+			} else if fullResponse != "" {
 				conv.append(provider.Message{
 					Role:    provider.RoleAssistant,
 					Content: fullResponse,

internal/action/loop.go

@@ -33,19 +33,38 @@ func (l *ToolLoop) Run(
 	opts provider.QueryOpts,
 	out chan<- provider.StreamChunk,
 ) error {
+	_, err := l.RunWithMessages(ctx, messages, toolCalls, opts, out)
+	return err
+}
+
+// RunWithMessages is like Run but also returns the messages appended during
+// the tool loop (tool results + follow-up assistant messages). These can be
+// used to preserve structured tool call history in the conversation state.
+func (l *ToolLoop) RunWithMessages(
+	ctx context.Context,
+	messages []provider.Message,
+	toolCalls []provider.ToolCall,
+	opts provider.QueryOpts,
+	out chan<- provider.StreamChunk,
+) ([]provider.Message, error) {
 	// Work on a copy so we don't mutate the caller's slice.
 	msgs := make([]provider.Message, len(messages))
 	copy(msgs, messages)
+	initialLen := len(msgs)
 
 	currentCalls := toolCalls
 
+	appended := func() []provider.Message {
+		return msgs[initialLen:]
+	}
+
 	for {
 		if len(currentCalls) == 0 {
 			select {
 			case out <- provider.StreamChunk{Done: true}:
 			case <-ctx.Done():
 			}
-			return nil
+			return appended(), nil
 		}
 
 		// The assistant message with ToolCalls is already in msgs:
@@ -61,7 +80,7 @@ func (l *ToolLoop) Run(
 				Status: true,
 			}:
 			case <-ctx.Done():
-				return ctx.Err()
+				return appended(), ctx.Err()
 			}
 
 			result := l.executor.Execute(call)
@@ -86,7 +105,7 @@ func (l *ToolLoop) Run(
 					Status: true,
 				}:
 				case <-ctx.Done():
-					return ctx.Err()
+					return appended(), ctx.Err()
 				}
 			}
 
@@ -101,22 +120,22 @@ func (l *ToolLoop) Run(
 		// Send updated conversation back to the model.
 		stream, err := l.primary.Query(ctx, msgs, opts)
 		if err != nil {
-			return fmt.Errorf("tool loop: %w", err)
+			return appended(), fmt.Errorf("tool loop: %w", err)
 		}
 
 		// Stream response chunks live to output, collecting for conversation state.
 		var responseContent string
 		var newToolCalls []provider.ToolCall
 		for chunk := range stream {
 			if chunk.Error != nil {
-				return fmt.Errorf("tool loop: %w", chunk.Error)
+				return appended(), fmt.Errorf("tool loop: %w", chunk.Error)
 			}
 			if chunk.Delta != "" {
 				responseContent += chunk.Delta
 				select {
 				case out <- provider.StreamChunk{Delta: chunk.Delta}:
 				case <-ctx.Done():
-					return ctx.Err()
+					return appended(), ctx.Err()
 				}
 			}
 			newToolCalls = append(newToolCalls, chunk.ToolCalls...)
@@ -147,6 +166,6 @@ func (l *ToolLoop) Run(
 		case out <- provider.StreamChunk{Done: true}:
 		case <-ctx.Done():
 		}
-		return nil
+		return appended(), nil
 	}
 }

internal/action/tools.go

@@ -72,3 +72,11 @@ func AllTools() []provider.ToolDefinition {
 		ShellExecTool(),
 	}
 }
+
+// ReadOnlyTools returns tool definitions that are safe for concurrent fan-out
+// execution — read-only operations with no side effects.
+func ReadOnlyTools() []provider.ToolDefinition {
+	return []provider.ToolDefinition{
+		FileReadTool(),
+	}
+}