Method readImageFile

pkg/tools/builtin/filesystem/filesystem.go:1036–1083

readImageFile reads an image file and returns it as base64-encoded image content. The caller must ensure the file exists (e.g. via os.Stat) before calling this method.

(resolvedPath, originalPath string)

// readImageFile reads an image file and returns it as base64-encoded image content.
// The caller must ensure the file exists (e.g. via os.Stat) before calling this method.
func (t *ToolSet) readImageFile(resolvedPath, originalPath string) (*tools.ToolCallResult, error) {
	data, err := t.readFile(resolvedPath)
	if err != nil {
		errMsg := err.Error()
		return &tools.ToolCallResult{
			Output:  errMsg,
			IsError: true,
			Meta: ReadFileMeta{
				Error: errMsg,
			},
		}, nil
	}

	mimeType := chat.DetectMimeType(resolvedPath)

	// Resize the image if it exceeds provider limits (max 2000×2000, max 4.5MB).
	resized, err := chat.ResizeImage(data, mimeType)
	if err != nil {
		// Check if the original exceeds limits before falling back
		if len(data) > chat.MaxImageBytes {
			return &tools.ToolCallResult{
				Output:  fmt.Sprintf("Error: Image file too large (%d bytes, max %d bytes)", len(data), chat.MaxImageBytes),
				IsError: true,
				Meta:    ReadFileMeta{Path: originalPath, Error: "image too large"},
			}, nil
		}
		// Original is within limits, proceed with fallback
		slog.Warn("Image resize failed, sending original (within limits)", "path", originalPath, "error", err)
		encoded := base64.StdEncoding.EncodeToString(data)
		return &tools.ToolCallResult{
			Output: fmt.Sprintf("Read image file %s [%s] (%d bytes)", originalPath, mimeType, len(data)),
			Images: []tools.ImageContent{{Data: encoded, MimeType: mimeType}},
			Meta:   ReadFileMeta{Path: originalPath},
		}, nil
	}

	encoded := base64.StdEncoding.EncodeToString(resized.Data)
	output := fmt.Sprintf("Read image file %s [%s] (%d bytes)", originalPath, resized.MimeType, len(resized.Data))
	if note := chat.FormatDimensionNote(resized); note != "" {
		output += "\n" + note
	}

	return &tools.ToolCallResult{
		Output: output,
		Images: []tools.ImageContent{{Data: encoded, MimeType: resized.MimeType}},
		Meta:   ReadFileMeta{Path: originalPath},
	}, nil
}

func (t *ToolSet) handleReadMultipleFiles(ctx context.Context, args ReadMultipleFilesArgs) (*tools.ToolCallResult, error) {
	annotateFilesystemSpan(ctx, "read_multiple_files", "")