Support read image

internal/backend/agent/bridge/exec/bridge.go

@@ -4,6 +4,7 @@ package execbridge
 import (
 	"encoding/json"
 	"fmt"
+	"net/http"
 	"strings"
 	"sync/atomic"
 	"time"
@@ -2285,6 +2286,18 @@ func buildReadMcpResourceCompletedToolCall(argsJSON []byte, result *agentv1.Read
 	}
 }
 
+func isSupportedReadImage(data []byte) bool {
+	if len(data) == 0 {
+		return false
+	}
+	switch strings.ToLower(strings.TrimSpace(http.DetectContentType(data))) {
+	case "image/png", "image/jpeg", "image/gif", "image/webp":
+		return true
+	default:
+		return false
+	}
+}
+
 // convertReadResultToReadToolResult 把 `ReadResult` 映射为 `ReadToolResult`。
 func convertReadResultToReadToolResult(result *agentv1.ReadResult) *agentv1.ReadToolResult {
 	if result == nil {
@@ -2318,7 +2331,9 @@ func convertReadResultToReadToolResult(result *agentv1.ReadResult) *agentv1.Read
 		if content != "" {
 			toolSuccess.Output = &agentv1.ReadToolSuccess_Content{Content: content}
 		} else if len(data) > 0 {
-			if len(data) > readReplayBinaryLimit {
+			if isSupportedReadImage(data) {
+				toolSuccess.Output = &agentv1.ReadToolSuccess_Data{Data: append([]byte(nil), data...)}
+			} else if len(data) > readReplayBinaryLimit {
 				toolSuccess.ExceededLimit = true
 				toolSuccess.Output = &agentv1.ReadToolSuccess_Content{
 					Content: replayTruncationNotice("Read binary data", readReplayBinaryLimit, 0, len(data)),

internal/backend/agent/model/anthropic.go

@@ -1126,7 +1126,16 @@ func isAnthropicCacheableBlock(block map[string]any) bool {
 	case contentPartTypeText:
 		return strings.TrimSpace(anthropicStringField(block, "text")) != ""
 	case "tool_result":
-		return strings.TrimSpace(anthropicStringField(block, "content")) != ""
+		switch content := block["content"].(type) {
+		case string:
+			return strings.TrimSpace(content) != ""
+		case []map[string]any:
+			return len(content) > 0
+		case []any:
+			return len(content) > 0
+		default:
+			return false
+		}
 	case "tool_use":
 		return strings.TrimSpace(anthropicStringField(block, "id")) != "" && strings.TrimSpace(anthropicStringField(block, "name")) != ""
 	default:
@@ -1168,10 +1177,18 @@ func normalizeAnthropicProviderMessages(input []Message, thinkingEnabled bool, r
 			if toolUseID == "" {
 				return nil, nil, fmt.Errorf("anthropic tool message requires tool_call_id")
 			}
+			var content any = message.Content
+			if hasImageContentParts(message.ContentParts) {
+				contentBlocks, err := anthropicContentBlocks(message)
+				if err != nil {
+					return nil, nil, err
+				}
+				content = contentBlocks
+			}
 			pendingToolResults = append(pendingToolResults, map[string]any{
 				"type":        "tool_result",
 				"tool_use_id": toolUseID,
-				"content":     message.Content,
+				"content":     content,
 			})
 		case "user", "assistant":
 			flushToolResults()

internal/backend/agent/model/openai.go

@@ -1967,10 +1967,18 @@ func normalizeOpenAIResponsesInput(messages []Message) (string, []map[string]any
 		}
 		if role == "tool" && strings.TrimSpace(message.ToolCallID) != "" {
 			callID := openAIResponsesToolMessageCallID(message, responsesCallIDs)
+			var output any = openAIResponsesMessageText(message)
+			if hasImageContentParts(message.ContentParts) {
+				content, err := openAIResponsesMessageContent(message, false)
+				if err != nil {
+					return "", nil, err
+				}
+				output = content
+			}
 			items = append(items, map[string]any{
 				"type":    "function_call_output",
 				"call_id": callID,
-				"output":  openAIResponsesMessageText(message),
+				"output":  output,
 			})
 			activeAssistantReasoningKey = ""
 			continue

internal/backend/forwarder/projector.go

@@ -5,6 +5,7 @@ import (
 	"crypto/sha256"
 	"encoding/json"
 	"fmt"
+	"net/http"
 	"strings"
 
 	"google.golang.org/protobuf/encoding/protojson"
@@ -215,6 +216,7 @@ func (projector *HistoryProjector) ProjectPromptReplay(conversation *Conversatio
 					if ok {
 						replayMessage.Name = toolName
 						replayMessage.Content = limitProjectedToolResultReplay(toolName, replayMessage.Content, payload.ResultText, true, historicalToolResult)
+						attachReadImageContentParts(&replayMessage, toolCall)
 						messages = append(messages, toModelMessage(replayMessage))
 						continue
 					}
@@ -249,12 +251,13 @@ func (projector *HistoryProjector) ProjectPromptReplay(conversation *Conversatio
 					replayMessages[index].OpenAIResponsesReasoningSummary = append(json.RawMessage(nil), payload.ReasoningSummary...)
 					applyPromptProviderMetadataToFirstToolCall(&replayMessages[index], payload.ProviderItemID, payload.ProviderCallID, payload.ProviderStatus)
 				}
-				for _, replay := range replayMessages {
-					if strings.TrimSpace(replay.Role) == "tool" {
-						toolName := firstNonEmpty(strings.TrimSpace(replay.Name), strings.TrimSpace(payload.ToolName))
-						replay.Content = limitProjectedToolResultReplay(toolName, replay.Content, payload.ResultText, true, historicalToolResult)
+				for index := range replayMessages {
+					if strings.TrimSpace(replayMessages[index].Role) == "tool" {
+						toolName := firstNonEmpty(strings.TrimSpace(replayMessages[index].Name), strings.TrimSpace(payload.ToolName))
+						replayMessages[index].Content = limitProjectedToolResultReplay(toolName, replayMessages[index].Content, payload.ResultText, true, historicalToolResult)
+						attachReadImageContentParts(&replayMessages[index], toolCall)
 					}
-					messages = append(messages, toModelMessage(replay))
+					messages = append(messages, toModelMessage(replayMessages[index]))
 				}
 				continue
 			}
@@ -305,6 +308,58 @@ func (projector *HistoryProjector) ProjectPromptReplay(conversation *Conversatio
 	return normalizeReplayMessageSequence(messages), nil
 }
 
+func attachReadImageContentParts(message *promptengine.Message, toolCall *agentv1.ToolCall) {
+	if message == nil || toolCall == nil || strings.TrimSpace(message.Role) != "tool" {
+		return
+	}
+	readToolCall := toolCall.GetReadToolCall()
+	if readToolCall == nil {
+		return
+	}
+	success := readToolCall.GetResult().GetSuccess()
+	if success == nil {
+		return
+	}
+	data := success.GetData()
+	mimeType := supportedReadImageMIMEType(data)
+	if mimeType == "" {
+		return
+	}
+	path := firstNonEmpty(strings.TrimSpace(success.GetPath()), strings.TrimSpace(readToolCall.GetArgs().GetPath()))
+	summary := fmt.Sprintf("read image path=%q mime=%s bytes=%d", path, mimeType, len(data))
+	if fileSize := success.GetFileSize(); fileSize > 0 && uint64(fileSize) != uint64(len(data)) {
+		summary += fmt.Sprintf(" file_size=%d", fileSize)
+	}
+	if success.GetExceededLimit() {
+		summary += " truncated=true"
+	}
+	message.Content = summary
+	message.ContentParts = []promptengine.ContentPart{
+		{Type: "text", Text: summary},
+		{
+			Type: "image",
+			Image: &promptengine.ImageContent{
+				MIMEType: mimeType,
+				Path:     path,
+				Data:     append([]byte(nil), data...),
+			},
+		},
+	}
+}
+
+func supportedReadImageMIMEType(data []byte) string {
+	if len(data) == 0 {
+		return ""
+	}
+	mimeType := strings.ToLower(strings.TrimSpace(http.DetectContentType(data)))
+	switch mimeType {
+	case "image/png", "image/jpeg", "image/gif", "image/webp":
+		return mimeType
+	default:
+		return ""
+	}
+}
+
 func compactedPromptProjectionEntries(entries []HistoryEntry) []HistoryEntry {
 	if len(entries) == 0 {
 		return nil